RTEMS 4.11
Annotated Report
Thu Dec 20 19:19:05 2012

4000c680 <IMFS_chown>:                                                
int IMFS_chown(                                                       
  const rtems_filesystem_location_info_t *loc,                        
  uid_t owner,                                                        
  gid_t group                                                         
)                                                                     
{                                                                     
4000c680:	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();                                                 
4000c684:	40 00 02 9e 	call  4000d0fc <geteuid>                       
4000c688:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
4000c68c:	c2 17 60 3c 	lduh  [ %i5 + 0x3c ], %g1                      
4000c690:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4000c694:	91 32 20 10 	srl  %o0, 0x10, %o0                            
4000c698:	80 a0 40 08 	cmp  %g1, %o0                                  
4000c69c:	02 80 00 04 	be  4000c6ac <IMFS_chown+0x2c>                 
4000c6a0:	80 a2 20 00 	cmp  %o0, 0                                    
4000c6a4:	12 80 00 0b 	bne  4000c6d0 <IMFS_chown+0x50>                <== ALWAYS TAKEN
4000c6a8:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( EPERM );                    
#endif                                                                
                                                                      
  jnode->st_uid = owner;                                              
4000c6ac:	f2 37 60 3c 	sth  %i1, [ %i5 + 0x3c ]                       
  jnode->st_gid = group;                                              
4000c6b0:	f4 37 60 3e 	sth  %i2, [ %i5 + 0x3e ]                       
                                                                      
  IMFS_update_ctime( jnode );                                         
4000c6b4:	90 07 bf f8 	add  %fp, -8, %o0                              
4000c6b8:	7f ff de fe 	call  400042b0 <gettimeofday>                  
4000c6bc:	92 10 20 00 	clr  %o1                                       
4000c6c0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000c6c4:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
                                                                      
  return 0;                                                           
}                                                                     
4000c6c8:	81 c7 e0 08 	ret                                            
4000c6cc:	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 );                    
4000c6d0:	40 00 10 9c 	call  40010940 <__errno>                       
4000c6d4:	b0 10 3f ff 	mov  -1, %i0                                   
4000c6d8:	82 10 20 01 	mov  1, %g1                                    
4000c6dc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000c6e0:	81 c7 e0 08 	ret                                            
4000c6e4:	81 e8 00 00 	restore                                        
                                                                      

400063d0 <IMFS_dump_directory>: */ static void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) {
400063d0:	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;                              
400063d4:	f4 06 20 50 	ld  [ %i0 + 0x50 ], %i2                        
400063d8:	39 10 00 9b 	sethi  %hi(0x40026c00), %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 ));            
400063dc:	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 );                    
400063e0:	80 a6 80 18 	cmp  %i2, %i0                                  
400063e4:	02 80 00 30 	be  400064a4 <IMFS_dump_directory+0xd4>        
400063e8:	b8 17 22 b8 	or  %i4, 0x2b8, %i4                            
400063ec:	37 10 00 93 	sethi  %hi(0x40024c00), %i3                    
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
400063f0:	29 10 00 93 	sethi  %hi(0x40024c00), %l4                    
      return;                                                         
  }                                                                   
  puts("");                                                           
400063f4:	21 10 00 95 	sethi  %hi(0x40025400), %l0                    
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
400063f8:	27 10 00 93 	sethi  %hi(0x40024c00), %l3                    
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
400063fc:	25 10 00 93 	sethi  %hi(0x40024c00), %l2                    
        the_node = the_node->next ) {                                 
                                                                      
    the_jnode = (IMFS_jnode_t *) the_node;                            
                                                                      
    for ( i=0 ; i<=level ; i++ )                                      
      fprintf(stdout, "...." );                                       
40006400:	b6 16 e2 38 	or  %i3, 0x238, %i3                            
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
      return;                                                         
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
40006404:	a8 15 22 a8 	or  %l4, 0x2a8, %l4                            
      return;                                                         
  }                                                                   
  puts("");                                                           
40006408:	a0 14 23 a8 	or  %l0, 0x3a8, %l0                            
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
4000640c:	a6 14 e2 90 	or  %l3, 0x290, %l3                            
    case IMFS_HARD_LINK:                                              
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
40006410:	a4 14 a2 78 	or  %l2, 0x278, %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 );                    
40006414:	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++ )                                      
40006418:	80 a6 60 00 	cmp  %i1, 0                                    
4000641c:	06 80 00 0c 	bl  4000644c <IMFS_dump_directory+0x7c>        <== NEVER TAKEN
40006420:	ba 10 20 00 	clr  %i5                                       
      fprintf(stdout, "...." );                                       
40006424:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40006428:	90 10 00 1b 	mov  %i3, %o0                                  
4000642c:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           
40006430:	92 10 20 01 	mov  1, %o1                                    
40006434:	40 00 3e 14 	call  40015c84 <fwrite>                        
40006438:	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++ )                                      
4000643c:	ba 07 60 01 	inc  %i5                                       
40006440:	80 a6 40 1d 	cmp  %i1, %i5                                  
40006444:	36 bf ff f9 	bge,a   40006428 <IMFS_dump_directory+0x58>    
40006448:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  IMFS_jnode_t *the_jnode                                             
)                                                                     
{                                                                     
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
4000644c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40006450:	90 06 a0 0c 	add  %i2, 0xc, %o0                             
40006454:	40 00 3a ee 	call  4001500c <fputs>                         
40006458:	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;                                    
4000645c:	c2 06 a0 4c 	ld  [ %i2 + 0x4c ], %g1                        
40006460:	d4 00 40 00 	ld  [ %g1 ], %o2                               
  switch( IMFS_type( the_jnode ) ) {                                  
40006464:	80 a2 a0 06 	cmp  %o2, 6                                    
40006468:	28 80 00 11 	bleu,a   400064ac <IMFS_dump_directory+0xdc>   <== ALWAYS TAKEN
4000646c:	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 ) );     
40006470:	c2 07 00 00 	ld  [ %i4 ], %g1                               <== NOT EXECUTED
40006474:	92 10 00 14 	mov  %l4, %o1                                  <== NOT EXECUTED
40006478:	40 00 3a 95 	call  40014ecc <fprintf>                       <== NOT EXECUTED
4000647c:	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;                  
40006480:	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 ) )                             
40006484:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40006488:	80 a0 60 00 	cmp  %g1, 0                                    
4000648c:	22 80 00 19 	be,a   400064f0 <IMFS_dump_directory+0x120>    
40006490:	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 ) {                                 
40006494:	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 );                    
40006498:	80 a6 80 18 	cmp  %i2, %i0                                  
4000649c:	12 bf ff e0 	bne  4000641c <IMFS_dump_directory+0x4c>       
400064a0:	80 a6 60 00 	cmp  %i1, 0                                    
400064a4:	81 c7 e0 08 	ret                                            
400064a8:	81 e8 00 00 	restore                                        
)                                                                     
{                                                                     
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
  switch( IMFS_type( the_jnode ) ) {                                  
400064ac:	03 10 00 18 	sethi  %hi(0x40006000), %g1                    
400064b0:	82 10 63 b4 	or  %g1, 0x3b4, %g1	! 400063b4 <bsp_interrupt_handler_default+0x18>
400064b4:	c2 00 40 0a 	ld  [ %g1 + %o2 ], %g1                         
400064b8:	81 c0 40 00 	jmp  %g1                                       
400064bc:	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" );                       
400064c0:	c2 07 00 00 	ld  [ %i4 ], %g1                               
400064c4:	90 10 00 12 	mov  %l2, %o0                                  
400064c8:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           
400064cc:	92 10 20 01 	mov  1, %o1                                    
400064d0:	40 00 3d ed 	call  40015c84 <fwrite>                        
400064d4:	94 10 20 13 	mov  0x13, %o2                                 
400064d8:	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 ) )                             
400064dc:	c2 00 40 00 	ld  [ %g1 ], %g1                               
400064e0:	80 a0 60 00 	cmp  %g1, 0                                    
400064e4:	32 bf ff ed 	bne,a   40006498 <IMFS_dump_directory+0xc8>    <== ALWAYS TAKEN
400064e8:	f4 06 80 00 	ld  [ %i2 ], %i2                               
      IMFS_dump_directory( the_jnode, level + 1 );                    
400064ec:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
400064f0:	7f ff ff b8 	call  400063d0 <IMFS_dump_directory>           
400064f4:	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 ) {                                 
400064f8:	10 bf ff e8 	b  40006498 <IMFS_dump_directory+0xc8>         
400064fc:	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)",                       
40006500:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40006504:	d4 06 a0 54 	ld  [ %i2 + 0x54 ], %o2                        
40006508:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
4000650c:	d6 06 a0 58 	ld  [ %i2 + 0x58 ], %o3                        
40006510:	13 10 00 93 	sethi  %hi(0x40024c00), %o1                    
40006514:	40 00 3a 6e 	call  40014ecc <fprintf>                       
40006518:	92 12 62 58 	or  %o1, 0x258, %o1	! 40024e58 <Callbacks.6428+0x158>
                                                                      
    default:                                                          
      fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );     
      return;                                                         
  }                                                                   
  puts("");                                                           
4000651c:	40 00 41 db 	call  40016c88 <puts>                          
40006520:	90 10 00 10 	mov  %l0, %o0                                  
40006524:	10 bf ff d8 	b  40006484 <IMFS_dump_directory+0xb4>         
40006528:	c2 06 a0 4c 	ld  [ %i2 + 0x4c ], %g1                        
    case IMFS_DIRECTORY:                                              
      fprintf(stdout, "/" );                                          
      break;                                                          
                                                                      
    case IMFS_DEVICE:                                                 
      fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",           
4000652c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40006530:	d4 06 a0 50 	ld  [ %i2 + 0x50 ], %o2                        
40006534:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
40006538:	d6 06 a0 54 	ld  [ %i2 + 0x54 ], %o3                        
4000653c:	13 10 00 93 	sethi  %hi(0x40024c00), %o1                    
40006540:	40 00 3a 63 	call  40014ecc <fprintf>                       
40006544:	92 12 62 40 	or  %o1, 0x240, %o1	! 40024e40 <Callbacks.6428+0x140>
40006548:	30 bf ff f5 	b,a   4000651c <IMFS_dump_directory+0x14c>     
  IMFS_assert( the_jnode );                                           
                                                                      
  fprintf(stdout, "%s", the_jnode->name );                            
  switch( IMFS_type( the_jnode ) ) {                                  
    case IMFS_DIRECTORY:                                              
      fprintf(stdout, "/" );                                          
4000654c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40006550:	90 10 20 2f 	mov  0x2f, %o0                                 
40006554:	40 00 3a 7a 	call  40014f3c <fputc>                         
40006558:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           
4000655c:	30 bf ff f0 	b,a   4000651c <IMFS_dump_directory+0x14c>     
    case IMFS_SYM_LINK:                                               
      fprintf(stdout, " links not printed\n" );                       
      return;                                                         
                                                                      
    case IMFS_FIFO:                                                   
      fprintf(stdout, " FIFO not printed\n" );                        
40006560:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40006564:	90 10 00 13 	mov  %l3, %o0                                  
40006568:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           
4000656c:	92 10 20 01 	mov  1, %o1                                    
40006570:	40 00 3d c5 	call  40015c84 <fwrite>                        
40006574:	94 10 20 12 	mov  0x12, %o2                                 
40006578:	10 bf ff c3 	b  40006484 <IMFS_dump_directory+0xb4>         
4000657c:	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 ")",                          
40006580:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40006584:	d4 06 a0 54 	ld  [ %i2 + 0x54 ], %o2                        
40006588:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
4000658c:	13 10 00 93 	sethi  %hi(0x40024c00), %o1                    
40006590:	40 00 3a 4f 	call  40014ecc <fprintf>                       
40006594:	92 12 62 68 	or  %o1, 0x268, %o1	! 40024e68 <Callbacks.6428+0x168>
40006598:	30 bf ff e1 	b,a   4000651c <IMFS_dump_directory+0x14c>     
                                                                      

4000c82c <IMFS_eval_token>: rtems_filesystem_eval_path_context_t *ctx, void *arg, const char *token, size_t tokenlen ) {
4000c82c:	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;                        
4000c830:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
  bool access_ok = rtems_filesystem_eval_path_check_access(           
4000c834:	90 10 00 18 	mov  %i0, %o0                                  
4000c838:	d4 07 20 30 	ld  [ %i4 + 0x30 ], %o2                        
4000c83c:	d6 17 20 3c 	lduh  [ %i4 + 0x3c ], %o3                      
4000c840:	d8 17 20 3e 	lduh  [ %i4 + 0x3e ], %o4                      
4000c844:	40 00 03 54 	call  4000d594 <rtems_filesystem_eval_path_check_access>
4000c848:	92 10 20 01 	mov  1, %o1                                    
    dir->st_mode,                                                     
    dir->st_uid,                                                      
    dir->st_gid                                                       
  );                                                                  
                                                                      
  if ( access_ok ) {                                                  
4000c84c:	80 8a 20 ff 	btst  0xff, %o0                                
4000c850:	12 80 00 04 	bne  4000c860 <IMFS_eval_token+0x34>           
4000c854:	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)) { 
4000c858:	81 c7 e0 08 	ret                                            
4000c85c:	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] == '.';                           
4000c860:	02 80 00 58 	be  4000c9c0 <IMFS_eval_token+0x194>           
4000c864:	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] == '.';       
4000c868:	22 80 00 37 	be,a   4000c944 <IMFS_eval_token+0x118>        
4000c86c:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000c870:	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 );           
4000c874:	b2 07 20 54 	add  %i4, 0x54, %i1                            
                                                                      
      while ( current != tail ) {                                     
4000c878:	80 a7 40 19 	cmp  %i5, %i1                                  
4000c87c:	02 80 00 30 	be  4000c93c <IMFS_eval_token+0x110>           
4000c880:	90 07 60 0c 	add  %i5, 0xc, %o0                             
        IMFS_jnode_t *entry = (IMFS_jnode_t *) current;               
        bool match = strncmp( entry->name, token, tokenlen ) == 0     
4000c884:	92 10 00 1a 	mov  %i2, %o1                                  
4000c888:	40 00 15 c5 	call  40011f9c <strncmp>                       
4000c88c:	94 10 00 1b 	mov  %i3, %o2                                  
          && entry->name [tokenlen] == '\0';                          
4000c890:	80 a2 20 00 	cmp  %o0, 0                                    
4000c894:	12 80 00 26 	bne  4000c92c <IMFS_eval_token+0x100>          
4000c898:	82 07 40 1b 	add  %i5, %i3, %g1                             
4000c89c:	c2 48 60 0c 	ldsb  [ %g1 + 0xc ], %g1                       
4000c8a0:	80 a0 60 00 	cmp  %g1, 0                                    
4000c8a4:	32 80 00 23 	bne,a   4000c930 <IMFS_eval_token+0x104>       
4000c8a8:	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;                                    
4000c8ac:	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 );    
4000c8b0:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
4000c8b4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000c8b8:	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;                                                  
4000c8bc:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
4000c8c0:	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;                                                  
4000c8c4:	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)) {
4000c8c8:	80 a0 60 02 	cmp  %g1, 2                                    
4000c8cc:	02 80 00 43 	be  4000c9d8 <IMFS_eval_token+0x1ac>           
4000c8d0:	86 10 00 02 	mov  %g2, %g3                                  
        entry = entry->info.hard_link.link_node;                      
      }                                                               
                                                                      
      if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) { 
4000c8d4:	80 a0 60 03 	cmp  %g1, 3                                    
4000c8d8:	02 80 00 28 	be  4000c978 <IMFS_eval_token+0x14c>           
4000c8dc:	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 ) {                                     
4000c8e0:	32 80 00 2c 	bne,a   4000c990 <IMFS_eval_token+0x164>       
4000c8e4:	c4 17 20 34 	lduh  [ %i4 + 0x34 ], %g2                      
    if ( node->info.directory.mt_fs != NULL ) {                       
4000c8e8:	f6 07 60 5c 	ld  [ %i5 + 0x5c ], %i3                        
4000c8ec:	80 a6 e0 00 	cmp  %i3, 0                                    
4000c8f0:	02 80 00 27 	be  4000c98c <IMFS_eval_token+0x160>           
4000c8f4:	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(        
4000c8f8:	d4 07 60 30 	ld  [ %i5 + 0x30 ], %o2                        
4000c8fc:	d6 17 60 3c 	lduh  [ %i5 + 0x3c ], %o3                      
4000c900:	d8 17 60 3e 	lduh  [ %i5 + 0x3e ], %o4                      
4000c904:	40 00 03 24 	call  4000d594 <rtems_filesystem_eval_path_check_access>
4000c908:	92 10 20 01 	mov  1, %o1                                    
            RTEMS_FS_PERMS_EXEC,                                      
            entry->st_mode,                                           
            entry->st_uid,                                            
            entry->st_gid                                             
          );                                                          
          if ( access_ok ) {                                          
4000c90c:	80 8a 20 ff 	btst  0xff, %o0                                
4000c910:	02 bf ff d2 	be  4000c858 <IMFS_eval_token+0x2c>            <== NEVER TAKEN
4000c914:	90 10 00 18 	mov  %i0, %o0                                  
            rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );   
4000c918:	92 06 e0 24 	add  %i3, 0x24, %o1                            
4000c91c:	7f ff e3 23 	call  400055a8 <rtems_filesystem_eval_path_restart>
4000c920:	b0 10 20 01 	mov  1, %i0                                    
4000c924:	81 c7 e0 08 	ret                                            
4000c928:	81 e8 00 00 	restore                                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
4000c92c:	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 ) {                                     
4000c930:	80 a6 40 1d 	cmp  %i1, %i5                                  
4000c934:	12 bf ff d4 	bne  4000c884 <IMFS_eval_token+0x58>           
4000c938:	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;           
4000c93c:	81 c7 e0 08 	ret                                            
4000c940:	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] == '.';       
4000c944:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000c948:	32 bf ff cb 	bne,a   4000c874 <IMFS_eval_token+0x48>        
4000c94c:	fa 07 20 50 	ld  [ %i4 + 0x50 ], %i5                        
4000c950:	c2 4e a0 01 	ldsb  [ %i2 + 1 ], %g1                         
4000c954:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000c958:	32 bf ff c7 	bne,a   4000c874 <IMFS_eval_token+0x48>        <== NEVER TAKEN
4000c95c:	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;                                             
4000c960:	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 ) {                                            
4000c964:	80 a7 60 00 	cmp  %i5, 0                                    
4000c968:	02 bf ff f5 	be  4000c93c <IMFS_eval_token+0x110>           
4000c96c:	01 00 00 00 	nop                                            
4000c970:	10 bf ff d0 	b  4000c8b0 <IMFS_eval_token+0x84>             
4000c974:	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)) { 
4000c978:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c97c:	02 80 00 20 	be  4000c9fc <IMFS_eval_token+0x1d0>           
4000c980:	80 89 20 10 	btst  0x10, %g4                                
4000c984:	32 80 00 1f 	bne,a   4000ca00 <IMFS_eval_token+0x1d4>       
4000c988:	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;                                     
4000c98c:	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;                            
4000c990:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
4000c994:	84 00 bf ff 	add  %g2, -1, %g2                              
4000c998:	c4 37 20 34 	sth  %g2, [ %i4 + 0x34 ]                       
          ++entry->reference_count;                                   
4000c99c:	c4 17 60 34 	lduh  [ %i5 + 0x34 ], %g2                      
4000c9a0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000c9a4:	84 00 a0 01 	inc  %g2                                       
4000c9a8:	c4 37 60 34 	sth  %g2, [ %i5 + 0x34 ]                       
          currentloc->node_access = entry;                            
4000c9ac:	fa 26 20 20 	st  %i5, [ %i0 + 0x20 ]                        
4000c9b0:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
4000c9b4:	b0 08 e0 ff 	and  %g3, 0xff, %i0                            
      status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;           
    }                                                                 
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
4000c9b8:	81 c7 e0 08 	ret                                            
4000c9bc:	81 e8 00 00 	restore                                        
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
4000c9c0:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
4000c9c4:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000c9c8:	32 bf ff ab 	bne,a   4000c874 <IMFS_eval_token+0x48>        
4000c9cc:	fa 07 20 50 	ld  [ %i4 + 0x50 ], %i5                        
4000c9d0:	10 bf ff b7 	b  4000c8ac <IMFS_eval_token+0x80>             
4000c9d4:	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)) {
4000c9d8:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c9dc:	12 80 00 04 	bne  4000c9ec <IMFS_eval_token+0x1c0>          
4000c9e0:	80 89 20 08 	btst  8, %g4                                   
        entry = entry->info.hard_link.link_node;                      
4000c9e4:	10 bf ff ea 	b  4000c98c <IMFS_eval_token+0x160>            
4000c9e8:	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)) {
4000c9ec:	22 bf ff e9 	be,a   4000c990 <IMFS_eval_token+0x164>        
4000c9f0:	c4 17 20 34 	lduh  [ %i4 + 0x34 ], %g2                      
4000c9f4:	10 bf ff e6 	b  4000c98c <IMFS_eval_token+0x160>            
4000c9f8:	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;               
4000c9fc:	fa 07 60 50 	ld  [ %i5 + 0x50 ], %i5                        
                                                                      
        rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
4000ca00:	40 00 15 35 	call  40011ed4 <strlen>                        
4000ca04:	90 10 00 1d 	mov  %i5, %o0                                  
4000ca08:	92 10 00 1d 	mov  %i5, %o1                                  
4000ca0c:	94 10 00 08 	mov  %o0, %o2                                  
4000ca10:	7f ff e2 ff 	call  4000560c <rtems_filesystem_eval_path_recursive>
4000ca14:	90 10 00 18 	mov  %i0, %o0                                  
4000ca18:	30 bf ff 90 	b,a   4000c858 <IMFS_eval_token+0x2c>          
                                                                      

4000ca34 <IMFS_fchmod>: int IMFS_fchmod( const rtems_filesystem_location_info_t *loc, mode_t mode ) {
4000ca34:	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();                                                 
4000ca38:	40 00 01 b1 	call  4000d0fc <geteuid>                       
4000ca3c:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
  if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )               
4000ca40:	c2 17 60 3c 	lduh  [ %i5 + 0x3c ], %g1                      
4000ca44:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4000ca48:	91 32 20 10 	srl  %o0, 0x10, %o0                            
4000ca4c:	80 a0 40 08 	cmp  %g1, %o0                                  
4000ca50:	02 80 00 04 	be  4000ca60 <IMFS_fchmod+0x2c>                
4000ca54:	80 a2 20 00 	cmp  %o0, 0                                    
4000ca58:	12 80 00 0e 	bne  4000ca90 <IMFS_fchmod+0x5c>               <== ALWAYS TAKEN
4000ca5c:	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);
4000ca60:	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 );                                         
4000ca64:	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);
4000ca68:	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 );                                         
4000ca6c:	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);
4000ca70:	b2 0e 6f ff 	and  %i1, 0xfff, %i1                           
4000ca74:	b2 16 40 01 	or  %i1, %g1, %i1                              
                                                                      
  IMFS_update_ctime( jnode );                                         
4000ca78:	7f ff de 0e 	call  400042b0 <gettimeofday>                  
4000ca7c:	f2 27 60 30 	st  %i1, [ %i5 + 0x30 ]                        
4000ca80:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000ca84:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
                                                                      
  return 0;                                                           
}                                                                     
4000ca88:	81 c7 e0 08 	ret                                            
4000ca8c:	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 );                    
4000ca90:	40 00 0f ac 	call  40010940 <__errno>                       
4000ca94:	b0 10 3f ff 	mov  -1, %i0                                   
4000ca98:	82 10 20 01 	mov  1, %g1                                    
4000ca9c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000caa0:	81 c7 e0 08 	ret                                            
4000caa4:	81 e8 00 00 	restore                                        
                                                                      

4000445c <IMFS_fifo_write>: static ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
4000445c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  IMFS_jnode_t *jnode = iop->pathinfo.node_access;                    
40004460:	fa 06 20 1c 	ld  [ %i0 + 0x1c ], %i5                        
                                                                      
  int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);        
40004464:	96 10 00 18 	mov  %i0, %o3                                  
40004468:	d0 07 60 50 	ld  [ %i5 + 0x50 ], %o0                        
4000446c:	92 10 00 19 	mov  %i1, %o1                                  
40004470:	40 00 2b be 	call  4000f368 <pipe_write>                    
40004474:	94 10 00 1a 	mov  %i2, %o2                                  
  if (err > 0) {                                                      
40004478:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000447c:	04 80 00 09 	ble  400044a0 <IMFS_fifo_write+0x44>           
40004480:	90 07 bf f8 	add  %fp, -8, %o0                              
    IMFS_mtime_ctime_update(jnode);                                   
40004484:	40 00 03 c5 	call  40005398 <gettimeofday>                  
40004488:	92 10 20 00 	clr  %o1                                       
4000448c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40004490:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
40004494:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
40004498:	81 c7 e0 08 	ret                                            
4000449c:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  IMFS_FIFO_RETURN(err);                                              
400044a0:	80 a6 20 00 	cmp  %i0, 0                                    
400044a4:	12 80 00 04 	bne  400044b4 <IMFS_fifo_write+0x58>           <== ALWAYS TAKEN
400044a8:	01 00 00 00 	nop                                            
}                                                                     
400044ac:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400044b0:	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);                                              
400044b4:	40 00 38 89 	call  400126d8 <__errno>                       
400044b8:	01 00 00 00 	nop                                            
400044bc:	82 20 00 18 	neg  %i0, %g1                                  
400044c0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
400044c4:	81 c7 e0 08 	ret                                            
400044c8:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

4000caa8 <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 ) {
4000caa8:	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;                         
4000caac:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
4000cab0:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
4000cab4:	f2 00 80 00 	ld  [ %g2 ], %i1                               
4000cab8:	f4 00 a0 04 	ld  [ %g2 + 4 ], %i2                           
4000cabc:	f6 00 a0 0c 	ld  [ %g2 + 0xc ], %i3                         
4000cac0:	f8 00 a0 10 	ld  [ %g2 + 0x10 ], %i4                        
4000cac4:	c8 00 a0 14 	ld  [ %g2 + 0x14 ], %g4                        
4000cac8:	c2 00 e0 4c 	ld  [ %g3 + 0x4c ], %g1                        
4000cacc:	f2 27 bf e8 	st  %i1, [ %fp + -24 ]                         
4000cad0:	f4 27 bf ec 	st  %i2, [ %fp + -20 ]                         
4000cad4:	c6 27 bf f0 	st  %g3, [ %fp + -16 ]                         
4000cad8:	f6 27 bf f4 	st  %i3, [ %fp + -12 ]                         
4000cadc:	f8 27 bf f8 	st  %i4, [ %fp + -8 ]                          
4000cae0:	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;            
4000cae4:	c0 20 a0 08 	clr  [ %g2 + 8 ]                               
4000cae8:	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;                           
4000caec:	ba 10 00 03 	mov  %g3, %i5                                  
4000caf0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root->location.node_access = NULL;            
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
4000caf4:	f8 07 60 08 	ld  [ %i5 + 8 ], %i4                           
     loc.node_access = (void *)jnode;                                 
4000caf8:	fa 27 bf f0 	st  %i5, [ %fp + -16 ]                         
     IMFS_Set_handlers( &loc );                                       
                                                                      
     if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000cafc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000cb00:	12 80 00 13 	bne  4000cb4c <IMFS_fsunmount+0xa4>            <== NEVER TAKEN
4000cb04:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
4000cb08:	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 );                            
4000cb0c:	84 07 60 54 	add  %i5, 0x54, %g2                            
4000cb10:	80 a0 40 02 	cmp  %g1, %g2                                  
4000cb14:	02 80 00 0f 	be  4000cb50 <IMFS_fsunmount+0xa8>             
4000cb18:	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;                    
4000cb1c:	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);                                           
4000cb20:	80 a7 60 00 	cmp  %i5, 0                                    
4000cb24:	02 80 00 21 	be  4000cba8 <IMFS_fsunmount+0x100>            <== NEVER TAKEN
4000cb28:	01 00 00 00 	nop                                            
4000cb2c:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        
    */                                                                
                                                                      
   temp_mt_entry->mt_fs_root->location.node_access = NULL;            
                                                                      
   do {                                                               
     next = jnode->Parent;                                            
4000cb30:	f8 07 60 08 	ld  [ %i5 + 8 ], %i4                           
4000cb34:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000cb38:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
     loc.node_access = (void *)jnode;                                 
4000cb3c:	fa 27 bf f0 	st  %i5, [ %fp + -16 ]                         
     IMFS_Set_handlers( &loc );                                       
                                                                      
     if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000cb40:	80 a0 a0 00 	cmp  %g2, 0                                    
4000cb44:	02 bf ff f1 	be  4000cb08 <IMFS_fsunmount+0x60>             
4000cb48:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
        result = IMFS_rmnod( NULL, &loc );                            
4000cb4c:	90 10 20 00 	clr  %o0                                       
4000cb50:	7f ff dc 4b 	call  40003c7c <IMFS_rmnod>                    
4000cb54:	92 07 bf e8 	add  %fp, -24, %o1                             
        if ( result != 0 )                                            
4000cb58:	80 a2 20 00 	cmp  %o0, 0                                    
4000cb5c:	12 80 00 15 	bne  4000cbb0 <IMFS_fsunmount+0x108>           <== NEVER TAKEN
4000cb60:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
	  rtems_fatal_error_occurred( 0xdeadbeef );                          
        IMFS_node_destroy( jnode );                                   
4000cb64:	7f ff db 64 	call  400038f4 <IMFS_node_destroy>             
4000cb68:	90 10 00 1d 	mov  %i5, %o0                                  
        jnode = next;                                                 
     }                                                                
     if ( jnode != NULL ) {                                           
4000cb6c:	80 a7 20 00 	cmp  %i4, 0                                    
4000cb70:	02 80 00 0e 	be  4000cba8 <IMFS_fsunmount+0x100>            
4000cb74:	01 00 00 00 	nop                                            
4000cb78:	c2 07 20 4c 	ld  [ %i4 + 0x4c ], %g1                        
4000cb7c:	c4 00 40 00 	ld  [ %g1 ], %g2                               
       if ( IMFS_is_directory( jnode ) ) {                            
4000cb80:	80 a0 a0 00 	cmp  %g2, 0                                    
4000cb84:	12 bf ff db 	bne  4000caf0 <IMFS_fsunmount+0x48>            <== NEVER TAKEN
4000cb88:	ba 10 00 1c 	mov  %i4, %i5                                  
4000cb8c:	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 );                            
4000cb90:	86 07 20 54 	add  %i4, 0x54, %g3                            
         if ( jnode_has_children( jnode ) )                           
4000cb94:	80 a7 40 03 	cmp  %i5, %g3                                  
4000cb98:	12 bf ff e3 	bne  4000cb24 <IMFS_fsunmount+0x7c>            
4000cb9c:	80 a7 60 00 	cmp  %i5, 0                                    
4000cba0:	10 bf ff d4 	b  4000caf0 <IMFS_fsunmount+0x48>              
4000cba4:	ba 10 00 1c 	mov  %i4, %i5                                  
4000cba8:	81 c7 e0 08 	ret                                            
4000cbac:	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 );                          
4000cbb0:	7f ff f0 5c 	call  40008d20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
4000cbb4:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

400037e0 <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] ) {
400037e0:	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 ) );          
400037e4:	90 10 20 01 	mov  1, %o0                                    
400037e8:	40 00 01 d9 	call  40003f4c <calloc>                        
400037ec:	92 10 20 24 	mov  0x24, %o1                                 
                                                                      
  if ( fs_info != NULL ) {                                            
400037f0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400037f4:	02 80 00 34 	be  400038c4 <IMFS_initialize_support+0xe4>    
400037f8:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
    IMFS_jnode_t *root_node;                                          
                                                                      
    fs_info->instance = imfs_instance++;                              
400037fc:	c4 00 61 2c 	ld  [ %g1 + 0x12c ], %g2	! 4001fd2c <imfs_instance.6621>
    memcpy(                                                           
40003800:	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++;                              
40003804:	86 00 a0 01 	add  %g2, 1, %g3                               
    memcpy(                                                           
40003808:	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++;                              
4000380c:	c4 27 40 00 	st  %g2, [ %i5 ]                               
40003810:	c6 20 61 2c 	st  %g3, [ %g1 + 0x12c ]                       
    memcpy(                                                           
40003814:	40 00 36 9c 	call  40011284 <memcpy>                        
40003818:	90 07 60 08 	add  %i5, 8, %o0                               
      fs_info->node_controls,                                         
      node_controls,                                                  
      sizeof( fs_info->node_controls )                                
    );                                                                
                                                                      
    root_node = IMFS_allocate_node(                                   
4000381c:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
40003820:	90 10 00 1d 	mov  %i5, %o0                                  
40003824:	96 10 20 00 	clr  %o3                                       
40003828:	15 10 00 78 	sethi  %hi(0x4001e000), %o2                    
4000382c:	9a 10 20 00 	clr  %o5                                       
40003830:	94 12 a1 48 	or  %o2, 0x148, %o2                            
40003834:	19 00 00 10 	sethi  %hi(0x4000), %o4                        
40003838:	40 00 23 ac 	call  4000c6e8 <IMFS_allocate_node>            
4000383c:	98 13 21 ed 	or  %o4, 0x1ed, %o4	! 41ed <PROM_START+0x41ed> 
      "",                                                             
      0,                                                              
      (S_IFDIR | 0755),                                               
      NULL                                                            
    );                                                                
    if ( root_node != NULL ) {                                        
40003840:	80 a2 20 00 	cmp  %o0, 0                                    
40003844:	02 80 00 20 	be  400038c4 <IMFS_initialize_support+0xe4>    <== NEVER TAKEN
40003848:	09 10 00 78 	sethi  %hi(0x4001e000), %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;                            
4000384c:	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;         
40003850:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
40003854:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
      0,                                                              
      (S_IFDIR | 0755),                                               
      NULL                                                            
    );                                                                
    if ( root_node != NULL ) {                                        
      mt_entry->fs_info = fs_info;                                    
40003858:	fa 26 20 08 	st  %i5, [ %i0 + 8 ]                           
      mt_entry->ops = op_table;                                       
4000385c:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
    errno = ENOMEM;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    IMFS_determine_bytes_per_block(                                   
40003860:	05 10 00 7d 	sethi  %hi(0x4001f400), %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;
40003864:	88 11 23 b4 	or  %g4, 0x3b4, %g4                            
    errno = ENOMEM;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    IMFS_determine_bytes_per_block(                                   
40003868:	c4 00 a1 a0 	ld  [ %g2 + 0x1a0 ], %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;
4000386c:	c8 26 20 2c 	st  %g4, [ %i0 + 0x2c ]                        
      mt_entry->mt_fs_root->location.node_access = root_node;         
40003870:	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) {                      
40003874:	80 a0 a0 10 	cmp  %g2, 0x10                                 
40003878:	02 80 00 0f 	be  400038b4 <IMFS_initialize_support+0xd4>    
4000387c:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
      is_valid = true;                                                
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
40003880:	80 a0 a0 0f 	cmp  %g2, 0xf                                  
40003884:	04 80 00 0b 	ble  400038b0 <IMFS_initialize_support+0xd0>   
40003888:	82 10 20 20 	mov  0x20, %g1                                 
4000388c:	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) {                      
40003890:	80 a0 80 01 	cmp  %g2, %g1                                  
40003894:	22 80 00 09 	be,a   400038b8 <IMFS_initialize_support+0xd8> 
40003898:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
      is_valid = true;                                                
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
4000389c:	26 80 00 06 	bl,a   400038b4 <IMFS_initialize_support+0xd4> <== NEVER TAKEN
400038a0:	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) {
400038a4:	86 80 ff ff 	addcc  %g3, -1, %g3                            
400038a8:	12 bf ff fa 	bne  40003890 <IMFS_initialize_support+0xb0>   <== ALWAYS TAKEN
400038ac:	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);                                     
400038b0:	84 10 20 80 	mov  0x80, %g2                                 
      break;                                                          
    }                                                                 
    if(bit_mask > requested_bytes_per_block)                          
      break;                                                          
  }                                                                   
  *dest_bytes_per_block = ((is_valid)                                 
400038b4:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
400038b8:	c4 20 61 28 	st  %g2, [ %g1 + 0x128 ]	! 4001fd28 <imfs_memfile_bytes_per_block>
  const IMFS_node_control *const node_controls [IMFS_TYPE_COUNT]      
)                                                                     
{                                                                     
  static int imfs_instance;                                           
                                                                      
  int rv = 0;                                                         
400038bc:	81 c7 e0 08 	ret                                            
400038c0:	91 e8 20 00 	restore  %g0, 0, %o0                           
    } else {                                                          
      errno = ENOMEM;                                                 
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = ENOMEM;                                                   
400038c4:	40 00 34 1f 	call  40010940 <__errno>                       
400038c8:	b0 10 3f ff 	mov  -1, %i0                                   
400038cc:	82 10 20 0c 	mov  0xc, %g1                                  
400038d0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK                            
    );                                                                
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400038d4:	81 c7 e0 08 	ret                                            
400038d8:	81 e8 00 00 	restore                                        
                                                                      

400055f8 <IMFS_make_generic_node>: const char *path, mode_t mode, const IMFS_node_control *node_control, void *context ) {
400055f8:	9d e3 bf 48 	save  %sp, -184, %sp                           
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
400055fc:	03 10 00 70 	sethi  %hi(0x4001c000), %g1                    
40005600:	c2 00 63 dc 	ld  [ %g1 + 0x3dc ], %g1	! 4001c3dc <rtems_current_user_env>
                                                                      
  switch (mode & S_IFMT) {                                            
40005604:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
  void *context                                                       
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
40005608:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
4000560c:	b2 2e 40 01 	andn  %i1, %g1, %i1                            
                                                                      
  switch (mode & S_IFMT) {                                            
40005610:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
40005614:	82 0e 40 01 	and  %i1, %g1, %g1                             
40005618:	80 a0 40 02 	cmp  %g1, %g2                                  
4000561c:	22 80 00 0c 	be,a   4000564c <IMFS_make_generic_node+0x54>  
40005620:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40005624:	08 80 00 1d 	bleu  40005698 <IMFS_make_generic_node+0xa0>   <== NEVER TAKEN
40005628:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
4000562c:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
40005630:	80 a0 40 02 	cmp  %g1, %g2                                  
40005634:	02 80 00 05 	be  40005648 <IMFS_make_generic_node+0x50>     
40005638:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
4000563c:	80 a0 40 02 	cmp  %g1, %g2                                  
40005640:	12 80 00 19 	bne  400056a4 <IMFS_make_generic_node+0xac>    <== ALWAYS TAKEN
40005644:	01 00 00 00 	nop                                            
      rv = -1;                                                        
      break;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    if ( node_control->imfs_type == IMFS_GENERIC ) {                  
40005648:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4000564c:	80 a0 60 07 	cmp  %g1, 7                                    
40005650:	12 80 00 15 	bne  400056a4 <IMFS_make_generic_node+0xac>    
40005654:	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 =            
40005658:	94 10 20 78 	mov  0x78, %o2                                 
4000565c:	40 00 07 ac 	call  4000750c <rtems_filesystem_eval_path_start>
40005660:	90 07 bf c8 	add  %fp, -56, %o0                             
        rtems_filesystem_eval_path_start( &ctx, path, eval_flags );   
                                                                      
      if ( IMFS_is_imfs_instance( currentloc ) ) {                    
40005664:	7f ff ff d2 	call  400055ac <IMFS_is_imfs_instance>         
40005668:	ba 10 00 08 	mov  %o0, %i5                                  
4000566c:	80 8a 20 ff 	btst  0xff, %o0                                
40005670:	12 80 00 13 	bne  400056bc <IMFS_make_generic_node+0xc4>    
40005674:	d4 1f bf d0 	ldd  [ %fp + -48 ], %o2                        
          IMFS_update_mtime( parent );                                
        } else {                                                      
          rv = -1;                                                    
        }                                                             
      } else {                                                        
        rtems_filesystem_eval_path_error( &ctx, ENOTSUP );            
40005678:	90 07 bf c8 	add  %fp, -56, %o0                             
4000567c:	92 10 20 86 	mov  0x86, %o1                                 
40005680:	40 00 06 e7 	call  4000721c <rtems_filesystem_eval_path_error>
40005684:	b0 10 3f ff 	mov  -1, %i0                                   
        rv = -1;                                                      
      }                                                               
                                                                      
      rtems_filesystem_eval_path_cleanup( &ctx );                     
40005688:	40 00 07 e1 	call  4000760c <rtems_filesystem_eval_path_cleanup>
4000568c:	90 07 bf c8 	add  %fp, -56, %o0                             
40005690:	81 c7 e0 08 	ret                                            
40005694:	81 e8 00 00 	restore                                        
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
                                                                      
  switch (mode & S_IFMT) {                                            
40005698:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
4000569c:	22 bf ff ec 	be,a   4000564c <IMFS_make_generic_node+0x54>  <== NOT EXECUTED
400056a0:	c2 06 80 00 	ld  [ %i2 ], %g1                               <== NOT EXECUTED
        rv = -1;                                                      
      }                                                               
                                                                      
      rtems_filesystem_eval_path_cleanup( &ctx );                     
    } else {                                                          
      errno = EINVAL;                                                 
400056a4:	40 00 40 b0 	call  40015964 <__errno>                       
400056a8:	b0 10 3f ff 	mov  -1, %i0                                   
400056ac:	82 10 20 16 	mov  0x16, %g1                                 
400056b0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400056b4:	81 c7 e0 08 	ret                                            
400056b8:	81 e8 00 00 	restore                                        
                                                                      
      if ( IMFS_is_imfs_instance( currentloc ) ) {                    
        IMFS_types_union info;                                        
        IMFS_jnode_t *new_node;                                       
                                                                      
        info.generic.context = context;                               
400056bc:	f6 27 bf b0 	st  %i3, [ %fp + -80 ]                         
        new_node = IMFS_create_node_with_control(                     
400056c0:	90 10 00 1d 	mov  %i5, %o0                                  
400056c4:	92 10 00 1a 	mov  %i2, %o1                                  
400056c8:	98 10 00 19 	mov  %i1, %o4                                  
400056cc:	9a 07 bf b0 	add  %fp, -80, %o5                             
400056d0:	40 00 2f fb 	call  400116bc <IMFS_create_node_with_control> 
400056d4:	b0 10 3f ff 	mov  -1, %i0                                   
          rtems_filesystem_eval_path_get_tokenlen( &ctx ),            
          mode,                                                       
          &info                                                       
        );                                                            
                                                                      
        if ( new_node != NULL ) {                                     
400056d8:	80 a2 20 00 	cmp  %o0, 0                                    
400056dc:	02 bf ff eb 	be  40005688 <IMFS_make_generic_node+0x90>     
400056e0:	92 10 20 00 	clr  %o1                                       
          IMFS_jnode_t *parent = currentloc->node_access;             
400056e4:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
                                                                      
          IMFS_update_ctime( parent );                                
400056e8:	40 00 02 0f 	call  40005f24 <gettimeofday>                  
400056ec:	90 07 bf a8 	add  %fp, -88, %o0                             
400056f0:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
          IMFS_update_mtime( parent );                                
400056f4:	90 07 bf a8 	add  %fp, -88, %o0                             
        );                                                            
                                                                      
        if ( new_node != NULL ) {                                     
          IMFS_jnode_t *parent = currentloc->node_access;             
                                                                      
          IMFS_update_ctime( parent );                                
400056f8:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
          IMFS_update_mtime( parent );                                
400056fc:	40 00 02 0a 	call  40005f24 <gettimeofday>                  
40005700:	92 10 20 00 	clr  %o1                                       
40005704:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
40005708:	b0 10 20 00 	clr  %i0                                       
4000570c:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
      } else {                                                        
        rtems_filesystem_eval_path_error( &ctx, ENOTSUP );            
        rv = -1;                                                      
      }                                                               
                                                                      
      rtems_filesystem_eval_path_cleanup( &ctx );                     
40005710:	40 00 07 bf 	call  4000760c <rtems_filesystem_eval_path_cleanup>
40005714:	90 07 bf c8 	add  %fp, -56, %o0                             
40005718:	81 c7 e0 08 	ret                                            
4000571c:	81 e8 00 00 	restore                                        
                                                                      

4000f3d0 <IMFS_memfile_addblock>: */ MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) {
4000f3d0:	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 );
4000f3d4:	94 10 20 01 	mov  1, %o2                                    
4000f3d8:	90 10 00 18 	mov  %i0, %o0                                  
4000f3dc:	7f ff fe c9 	call  4000ef00 <IMFS_memfile_get_block_pointer>
4000f3e0:	92 10 00 19 	mov  %i1, %o1                                  
  if ( *block_entry_ptr )                                             
4000f3e4:	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 );
4000f3e8:	ba 10 00 08 	mov  %o0, %i5                                  
  if ( *block_entry_ptr )                                             
4000f3ec:	80 a0 60 00 	cmp  %g1, 0                                    
4000f3f0:	12 80 00 08 	bne  4000f410 <IMFS_memfile_addblock+0x40>     
4000f3f4:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
                                                                      
  /*                                                                  
   *  There is no memory for this block number so allocate it.        
   */                                                                 
  memory = memfile_alloc_block();                                     
4000f3f8:	7f ff fe b5 	call  4000eecc <memfile_alloc_block>           
4000f3fc:	01 00 00 00 	nop                                            
  if ( !memory )                                                      
4000f400:	80 a2 20 00 	cmp  %o0, 0                                    
4000f404:	02 80 00 05 	be  4000f418 <IMFS_memfile_addblock+0x48>      <== NEVER TAKEN
4000f408:	01 00 00 00 	nop                                            
    return 1;                                                         
                                                                      
  *block_entry_ptr = memory;                                          
4000f40c:	d0 27 40 00 	st  %o0, [ %i5 ]                               
  return 0;                                                           
4000f410:	81 c7 e0 08 	ret                                            
4000f414:	81 e8 00 00 	restore                                        
}                                                                     
4000f418:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f41c:	91 e8 20 01 	restore  %g0, 1, %o0                           <== NOT EXECUTED
                                                                      

4000f644 <IMFS_memfile_extend>: MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, bool zero_fill, off_t new_length ) {
4000f644:	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 )                      
4000f648:	25 10 00 7f 	sethi  %hi(0x4001fc00), %l2                    
4000f64c:	fa 04 a1 28 	ld  [ %l2 + 0x128 ], %i5	! 4001fd28 <imfs_memfile_bytes_per_block>
4000f650:	b9 37 60 02 	srl  %i5, 2, %i4                               
4000f654:	92 10 00 1c 	mov  %i4, %o1                                  
4000f658:	40 00 28 cd 	call  4001998c <.umul>                         
4000f65c:	90 07 20 01 	add  %i4, 1, %o0                               
4000f660:	92 10 00 1c 	mov  %i4, %o1                                  
4000f664:	40 00 28 ca 	call  4001998c <.umul>                         
4000f668:	90 02 20 01 	inc  %o0                                       
4000f66c:	92 10 00 1d 	mov  %i5, %o1                                  
4000f670:	40 00 28 c7 	call  4001998c <.umul>                         
4000f674:	90 02 3f ff 	add  %o0, -1, %o0                              
4000f678:	82 10 20 00 	clr  %g1                                       
4000f67c:	80 a0 40 1a 	cmp  %g1, %i2                                  
4000f680:	04 80 00 58 	ble  4000f7e0 <IMFS_memfile_extend+0x19c>      <== ALWAYS TAKEN
4000f684:	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 )                      
4000f688:	e2 07 20 50 	ld  [ %i4 + 0x50 ], %l1                        <== NOT EXECUTED
4000f68c:	80 a6 80 11 	cmp  %i2, %l1                                  
4000f690:	04 80 00 3f 	ble  4000f78c <IMFS_memfile_extend+0x148>      <== ALWAYS TAKEN
4000f694:	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;             
4000f698:	a7 3f 60 1f 	sra  %i5, 0x1f, %l3                            <== NOT EXECUTED
4000f69c:	96 10 00 1d 	mov  %i5, %o3                                  
4000f6a0:	94 10 00 13 	mov  %l3, %o2                                  
4000f6a4:	90 10 00 1a 	mov  %i2, %o0                                  
4000f6a8:	40 00 2a 4b 	call  40019fd4 <__divdi3>                      
4000f6ac:	92 10 00 1b 	mov  %i3, %o1                                  
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f6b0:	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;             
4000f6b4:	b0 10 00 09 	mov  %o1, %i0                                  
  old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f6b8:	90 10 00 11 	mov  %l1, %o0                                  
4000f6bc:	92 10 00 10 	mov  %l0, %o1                                  
4000f6c0:	40 00 2a 45 	call  40019fd4 <__divdi3>                      
4000f6c4:	94 10 00 13 	mov  %l3, %o2                                  
4000f6c8:	a2 10 00 09 	mov  %o1, %l1                                  
  offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
4000f6cc:	90 10 00 09 	mov  %o1, %o0                                  
4000f6d0:	40 00 28 af 	call  4001998c <.umul>                         
4000f6d4:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
  /*                                                                  
   *  Now allocate each of those blocks.                              
   */                                                                 
  for ( block=old_blocks ; block<=new_blocks ; block++ ) {            
4000f6d8:	ba 10 00 11 	mov  %l1, %i5                                  
4000f6dc:	80 a6 00 11 	cmp  %i0, %l1                                  
4000f6e0:	1a 80 00 07 	bcc  4000f6fc <IMFS_memfile_extend+0xb8>       <== ALWAYS TAKEN
4000f6e4:	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);                                       
4000f6e8:	10 80 00 1d 	b  4000f75c <IMFS_memfile_extend+0x118>        <== NOT EXECUTED
4000f6ec:	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++ ) {            
4000f6f0:	80 a6 00 1d 	cmp  %i0, %i5                                  
4000f6f4:	0a 80 00 1a 	bcs  4000f75c <IMFS_memfile_extend+0x118>      
4000f6f8:	92 10 20 00 	clr  %o1                                       
    if ( !IMFS_memfile_addblock( the_jnode, block ) ) {               
4000f6fc:	92 10 00 1d 	mov  %i5, %o1                                  
4000f700:	7f ff ff 34 	call  4000f3d0 <IMFS_memfile_addblock>         
4000f704:	90 10 00 1c 	mov  %i4, %o0                                  
4000f708:	80 a2 20 00 	cmp  %o0, 0                                    
4000f70c:	12 80 00 26 	bne  4000f7a4 <IMFS_memfile_extend+0x160>      <== NEVER TAKEN
4000f710:	80 a6 60 00 	cmp  %i1, 0                                    
       if ( zero_fill ) {                                             
4000f714:	22 bf ff f7 	be,a   4000f6f0 <IMFS_memfile_extend+0xac>     
4000f718:	ba 07 60 01 	inc  %i5                                       
          size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;       
          block_p *block_ptr =                                        
4000f71c:	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;       
4000f720:	e6 04 a1 28 	ld  [ %l2 + 0x128 ], %l3                       
          block_p *block_ptr =                                        
4000f724:	94 10 20 00 	clr  %o2                                       
4000f728:	7f ff fd f6 	call  4000ef00 <IMFS_memfile_get_block_pointer>
4000f72c:	90 10 00 1c 	mov  %i4, %o0                                  
            IMFS_memfile_get_block_pointer( the_jnode, block, 0 );    
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
4000f730:	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;       
4000f734:	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);                  
4000f738:	90 02 00 10 	add  %o0, %l0, %o0                             
4000f73c:	92 10 20 00 	clr  %o1                                       
4000f740:	40 00 07 0e 	call  40011378 <memset>                        
4000f744:	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++ ) {            
4000f748:	ba 07 60 01 	inc  %i5                                       
4000f74c:	80 a6 00 1d 	cmp  %i0, %i5                                  
4000f750:	1a bf ff eb 	bcc  4000f6fc <IMFS_memfile_extend+0xb8>       
4000f754:	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);                                       
4000f758:	92 10 20 00 	clr  %o1                                       
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new length of the file.                                 
   */                                                                 
  the_jnode->info.file.size = new_length;                             
4000f75c:	f4 3f 20 50 	std  %i2, [ %i4 + 0x50 ]                       
                                                                      
  IMFS_update_ctime(the_jnode);                                       
4000f760:	7f ff d2 d4 	call  400042b0 <gettimeofday>                  
4000f764:	90 07 bf f8 	add  %fp, -8, %o0                              
4000f768:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  IMFS_update_mtime(the_jnode);                                       
4000f76c:	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);                                       
4000f770:	c2 27 20 48 	st  %g1, [ %i4 + 0x48 ]                        
  IMFS_update_mtime(the_jnode);                                       
4000f774:	7f ff d2 cf 	call  400042b0 <gettimeofday>                  
4000f778:	92 10 20 00 	clr  %o1                                       
4000f77c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000f780:	c2 27 20 44 	st  %g1, [ %i4 + 0x44 ]                        
  return 0;                                                           
4000f784:	81 c7 e0 08 	ret                                            
4000f788:	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 )                      
4000f78c:	12 80 00 04 	bne  4000f79c <IMFS_memfile_extend+0x158>      <== NEVER TAKEN
4000f790:	80 a6 c0 10 	cmp  %i3, %l0                                  
4000f794:	18 bf ff c2 	bgu  4000f69c <IMFS_memfile_extend+0x58>       <== ALWAYS TAKEN
4000f798:	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;                                                           
}                                                                     
4000f79c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f7a0:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
          offset = 0;                                                 
       }                                                              
    } else {                                                          
       for ( ; block>=old_blocks ; block-- ) {                        
4000f7a4:	80 a7 40 11 	cmp  %i5, %l1                                  <== NOT EXECUTED
4000f7a8:	0a 80 00 08 	bcs  4000f7c8 <IMFS_memfile_extend+0x184>      <== NOT EXECUTED
4000f7ac:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
         IMFS_memfile_remove_block( the_jnode, block );               
4000f7b0:	7f ff ff 99 	call  4000f614 <IMFS_memfile_remove_block>     <== NOT EXECUTED
4000f7b4:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
          memset( &(*block_ptr) [offset], 0, count);                  
          offset = 0;                                                 
       }                                                              
    } else {                                                          
       for ( ; block>=old_blocks ; block-- ) {                        
4000f7b8:	ba 07 7f ff 	add  %i5, -1, %i5                              <== NOT EXECUTED
4000f7bc:	80 a4 40 1d 	cmp  %l1, %i5                                  <== NOT EXECUTED
4000f7c0:	08 bf ff fc 	bleu  4000f7b0 <IMFS_memfile_extend+0x16c>     <== NOT EXECUTED
4000f7c4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
         IMFS_memfile_remove_block( the_jnode, block );               
       }                                                              
       rtems_set_errno_and_return_minus_one( ENOSPC );                
4000f7c8:	40 00 04 5e 	call  40010940 <__errno>                       <== NOT EXECUTED
4000f7cc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000f7d0:	82 10 20 1c 	mov  0x1c, %g1                                 <== NOT EXECUTED
4000f7d4:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000f7d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f7dc:	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 )                      
4000f7e0:	12 80 00 04 	bne  4000f7f0 <IMFS_memfile_extend+0x1ac>      <== NEVER TAKEN
4000f7e4:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000f7e8:	38 bf ff a9 	bgu,a   4000f68c <IMFS_memfile_extend+0x48>    
4000f7ec:	e2 07 20 50 	ld  [ %i4 + 0x50 ], %l1                        
    rtems_set_errno_and_return_minus_one( EFBIG );                    
4000f7f0:	40 00 04 54 	call  40010940 <__errno>                       
4000f7f4:	b0 10 3f ff 	mov  -1, %i0                                   
4000f7f8:	82 10 20 1b 	mov  0x1b, %g1                                 
4000f7fc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000f800:	81 c7 e0 08 	ret                                            
4000f804:	81 e8 00 00 	restore                                        
                                                                      

4000ef00 <IMFS_memfile_get_block_pointer>: #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) {
4000ef00:	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 ) {                                  
4000ef04:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
4000ef08:	fa 00 61 28 	ld  [ %g1 + 0x128 ], %i5	! 4001fd28 <imfs_memfile_bytes_per_block>
4000ef0c:	bb 37 60 02 	srl  %i5, 2, %i5                               
4000ef10:	82 07 7f ff 	add  %i5, -1, %g1                              
4000ef14:	80 a6 40 01 	cmp  %i1, %g1                                  
4000ef18:	38 80 00 0b 	bgu,a   4000ef44 <IMFS_memfile_get_block_pointer+0x44>
4000ef1c:	90 07 60 01 	add  %i5, 1, %o0                               
    p = info->indirect;                                               
                                                                      
    if ( malloc_it ) {                                                
4000ef20:	80 a6 a0 00 	cmp  %i2, 0                                    
4000ef24:	12 80 00 4e 	bne  4000f05c <IMFS_memfile_get_block_pointer+0x15c>
4000ef28:	d0 06 20 58 	ld  [ %i0 + 0x58 ], %o0                        
        info->indirect = p;                                           
      }                                                               
      return &info->indirect[ my_block ];                             
    }                                                                 
                                                                      
    if ( !p )                                                         
4000ef2c:	80 a2 20 00 	cmp  %o0, 0                                    
4000ef30:	02 80 00 6d 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ef34:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    return &info->indirect[ my_block ];                               
4000ef38:	b3 2e 60 02 	sll  %i1, 2, %i1                               
4000ef3c:	81 c7 e0 08 	ret                                            
4000ef40:	91 ea 00 19 	restore  %o0, %i1, %o0                         
                                                                      
  /*                                                                  
   *  Is the block number in the doubly indirect portion?             
   */                                                                 
                                                                      
  if ( my_block <= LAST_DOUBLY_INDIRECT ) {                           
4000ef44:	40 00 2a 92 	call  4001998c <.umul>                         
4000ef48:	92 10 00 1d 	mov  %i5, %o1                                  
4000ef4c:	82 02 3f ff 	add  %o0, -1, %g1                              
4000ef50:	80 a6 40 01 	cmp  %i1, %g1                                  
4000ef54:	08 80 00 2b 	bleu  4000f000 <IMFS_memfile_get_block_pointer+0x100>
4000ef58:	b8 10 00 08 	mov  %o0, %i4                                  
  }                                                                   
                                                                      
  /*                                                                  
   *  Is the block number in the triply indirect portion?             
   */                                                                 
  if ( my_block <= LAST_TRIPLY_INDIRECT ) {                           
4000ef5c:	90 02 20 01 	inc  %o0                                       
4000ef60:	40 00 2a 8b 	call  4001998c <.umul>                         
4000ef64:	92 10 00 1d 	mov  %i5, %o1                                  
4000ef68:	90 02 3f ff 	add  %o0, -1, %o0                              
4000ef6c:	80 a6 40 08 	cmp  %i1, %o0                                  
4000ef70:	18 80 00 5d 	bgu  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000ef74:	b2 26 40 1c 	sub  %i1, %i4, %i1                             
    my_block -= FIRST_TRIPLY_INDIRECT;                                
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
4000ef78:	92 10 00 1d 	mov  %i5, %o1                                  
4000ef7c:	40 00 2b 6a 	call  40019d24 <.urem>                         
4000ef80:	90 10 00 19 	mov  %i1, %o0                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
4000ef84:	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;                     
4000ef88:	a0 10 00 08 	mov  %o0, %l0                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
4000ef8c:	40 00 2a ba 	call  40019a74 <.udiv>                         
4000ef90:	90 10 00 19 	mov  %i1, %o0                                  
    triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;                       
4000ef94:	92 10 00 1d 	mov  %i5, %o1                                  
4000ef98:	40 00 2a b7 	call  40019a74 <.udiv>                         
4000ef9c:	b8 10 00 08 	mov  %o0, %i4                                  
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
4000efa0:	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;                       
4000efa4:	b6 10 00 08 	mov  %o0, %i3                                  
    doubly %= IMFS_MEMFILE_BLOCK_SLOTS;                               
4000efa8:	40 00 2b 5f 	call  40019d24 <.urem>                         
4000efac:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
4000efb0:	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;                               
4000efb4:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
4000efb8:	02 80 00 3d 	be  4000f0ac <IMFS_memfile_get_block_pointer+0x1ac>
4000efbc:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
      if ( !p ) {                                                     
4000efc0:	80 a2 20 00 	cmp  %o0, 0                                    
4000efc4:	02 80 00 66 	be  4000f15c <IMFS_memfile_get_block_pointer+0x25c>
4000efc8:	01 00 00 00 	nop                                            
        if ( !p )                                                     
           return 0;                                                  
        info->triply_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
4000efcc:	b7 2e e0 02 	sll  %i3, 2, %i3                               
4000efd0:	c4 02 00 1b 	ld  [ %o0 + %i3 ], %g2                         
      if ( !p1 ) {                                                    
4000efd4:	80 a0 a0 00 	cmp  %g2, 0                                    
4000efd8:	02 80 00 5a 	be  4000f140 <IMFS_memfile_get_block_pointer+0x240>
4000efdc:	b6 02 00 1b 	add  %o0, %i3, %i3                             
        if ( !p1 )                                                    
           return 0;                                                  
        p[ triply ] = (block_p) p1;                                   
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
4000efe0:	bb 2f 60 02 	sll  %i5, 2, %i5                               
4000efe4:	d0 00 80 1d 	ld  [ %g2 + %i5 ], %o0                         
      if ( !p2 ) {                                                    
4000efe8:	80 a2 20 00 	cmp  %o0, 0                                    
4000efec:	02 80 00 47 	be  4000f108 <IMFS_memfile_get_block_pointer+0x208>
4000eff0:	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 ];                                
4000eff4:	b1 2c 20 02 	sll  %l0, 2, %i0                               
4000eff8:	81 c7 e0 08 	ret                                            
4000effc:	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;                                
4000f000:	b2 26 40 1d 	sub  %i1, %i5, %i1                             
                                                                      
    singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;                     
4000f004:	92 10 00 1d 	mov  %i5, %o1                                  
4000f008:	40 00 2b 47 	call  40019d24 <.urem>                         
4000f00c:	90 10 00 19 	mov  %i1, %o0                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
4000f010:	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;                     
4000f014:	b8 10 00 08 	mov  %o0, %i4                                  
    doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;                     
4000f018:	40 00 2a 97 	call  40019a74 <.udiv>                         
4000f01c:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    p = info->doubly_indirect;                                        
4000f020:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
    if ( malloc_it ) {                                                
4000f024:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f028:	02 80 00 17 	be  4000f084 <IMFS_memfile_get_block_pointer+0x184>
4000f02c:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
      if ( !p ) {                                                     
4000f030:	80 a0 60 00 	cmp  %g1, 0                                    
4000f034:	02 80 00 3c 	be  4000f124 <IMFS_memfile_get_block_pointer+0x224>
4000f038:	01 00 00 00 	nop                                            
        if ( !p )                                                     
           return 0;                                                  
        info->doubly_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *)p[ doubly ];                                    
4000f03c:	bb 2f 60 02 	sll  %i5, 2, %i5                               
4000f040:	d0 00 40 1d 	ld  [ %g1 + %i5 ], %o0                         
      if ( !p1 ) {                                                    
4000f044:	80 a2 20 00 	cmp  %o0, 0                                    
4000f048:	02 80 00 29 	be  4000f0ec <IMFS_memfile_get_block_pointer+0x1ec>
4000f04c:	ba 00 40 1d 	add  %g1, %i5, %i5                             
        if ( !p1 )                                                    
           return 0;                                                  
        p[ doubly ] = (block_p) p1;                                   
      }                                                               
                                                                      
      return (block_p *)&p1[ singly ];                                
4000f050:	b1 2f 20 02 	sll  %i4, 2, %i0                               
4000f054:	81 c7 e0 08 	ret                                            
4000f058:	91 ea 00 18 	restore  %o0, %i0, %o0                         
  if ( my_block <= LAST_INDIRECT ) {                                  
    p = info->indirect;                                               
                                                                      
    if ( malloc_it ) {                                                
                                                                      
      if ( !p ) {                                                     
4000f05c:	80 a2 20 00 	cmp  %o0, 0                                    
4000f060:	32 bf ff b7 	bne,a   4000ef3c <IMFS_memfile_get_block_pointer+0x3c>
4000f064:	b3 2e 60 02 	sll  %i1, 2, %i1                               
        p = memfile_alloc_block();                                    
4000f068:	7f ff ff 99 	call  4000eecc <memfile_alloc_block>           
4000f06c:	01 00 00 00 	nop                                            
        if ( !p )                                                     
4000f070:	80 a2 20 00 	cmp  %o0, 0                                    
4000f074:	02 80 00 1c 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f078:	01 00 00 00 	nop                                            
           return 0;                                                  
        info->indirect = p;                                           
4000f07c:	10 bf ff af 	b  4000ef38 <IMFS_memfile_get_block_pointer+0x38>
4000f080:	d0 26 20 58 	st  %o0, [ %i0 + 0x58 ]                        
      }                                                               
                                                                      
      return (block_p *)&p1[ singly ];                                
    }                                                                 
                                                                      
    if ( !p )                                                         
4000f084:	80 a0 60 00 	cmp  %g1, 0                                    
4000f088:	02 80 00 17 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f08c:	bb 2a 20 02 	sll  %o0, 2, %i5                               
      return 0;                                                       
                                                                      
    p = (block_p *)p[ doubly ];                                       
4000f090:	c2 00 40 1d 	ld  [ %g1 + %i5 ], %g1                         
    if ( !p )                                                         
4000f094:	80 a0 60 00 	cmp  %g1, 0                                    
4000f098:	02 80 00 13 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f09c:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    return (block_p *)&p[ singly ];                                   
4000f0a0:	b1 2f 20 02 	sll  %i4, 2, %i0                               
4000f0a4:	81 c7 e0 08 	ret                                            
4000f0a8:	91 e8 40 18 	restore  %g1, %i0, %o0                         
        p1[ doubly ] = (block_p) p2;                                  
      }                                                               
      return (block_p *)&p2[ singly ];                                
    }                                                                 
                                                                      
    if ( !p )                                                         
4000f0ac:	80 a2 20 00 	cmp  %o0, 0                                    
4000f0b0:	02 80 00 0d 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f0b4:	b7 2e e0 02 	sll  %i3, 2, %i3                               
      return 0;                                                       
                                                                      
    p1 = (block_p *) p[ triply ];                                     
4000f0b8:	c2 02 00 1b 	ld  [ %o0 + %i3 ], %g1                         
    if ( !p1 )                                                        
4000f0bc:	80 a0 60 00 	cmp  %g1, 0                                    
4000f0c0:	02 80 00 09 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f0c4:	bb 2f 60 02 	sll  %i5, 2, %i5                               
      return 0;                                                       
                                                                      
    p2 = (block_p *)p1[ doubly ];                                     
4000f0c8:	c2 00 40 1d 	ld  [ %g1 + %i5 ], %g1                         
    if ( !p2 )                                                        
4000f0cc:	80 a0 60 00 	cmp  %g1, 0                                    
4000f0d0:	02 80 00 05 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f0d4:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    return (block_p *)&p2[ singly ];                                  
4000f0d8:	b1 2c 20 02 	sll  %l0, 2, %i0                               
                                                                      
  /*                                                                  
   *  This means the requested block number is out of range.          
   */                                                                 
  return 0;                                                           
}                                                                     
4000f0dc:	81 c7 e0 08 	ret                                            
4000f0e0:	91 e8 40 18 	restore  %g1, %i0, %o0                         
    if ( malloc_it ) {                                                
                                                                      
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
        if ( !p )                                                     
           return 0;                                                  
4000f0e4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f0e8:	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();                                   
4000f0ec:	7f ff ff 78 	call  4000eecc <memfile_alloc_block>           
4000f0f0:	01 00 00 00 	nop                                            
        if ( !p1 )                                                    
4000f0f4:	80 a2 20 00 	cmp  %o0, 0                                    
4000f0f8:	02 bf ff fb 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f0fc:	01 00 00 00 	nop                                            
           return 0;                                                  
        p[ doubly ] = (block_p) p1;                                   
4000f100:	10 bf ff d4 	b  4000f050 <IMFS_memfile_get_block_pointer+0x150>
4000f104:	d0 27 40 00 	st  %o0, [ %i5 ]                               
        p[ triply ] = (block_p) p1;                                   
      }                                                               
                                                                      
      p2 = (block_p *)p1[ doubly ];                                   
      if ( !p2 ) {                                                    
        p2 = memfile_alloc_block();                                   
4000f108:	7f ff ff 71 	call  4000eecc <memfile_alloc_block>           
4000f10c:	01 00 00 00 	nop                                            
        if ( !p2 )                                                    
4000f110:	80 a2 20 00 	cmp  %o0, 0                                    
4000f114:	02 bf ff f4 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f118:	01 00 00 00 	nop                                            
           return 0;                                                  
        p1[ doubly ] = (block_p) p2;                                  
4000f11c:	10 bf ff b6 	b  4000eff4 <IMFS_memfile_get_block_pointer+0xf4>
4000f120:	d0 27 40 00 	st  %o0, [ %i5 ]                               
                                                                      
    p = info->doubly_indirect;                                        
    if ( malloc_it ) {                                                
                                                                      
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
4000f124:	7f ff ff 6a 	call  4000eecc <memfile_alloc_block>           
4000f128:	01 00 00 00 	nop                                            
        if ( !p )                                                     
4000f12c:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000f130:	02 bf ff ed 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f134:	01 00 00 00 	nop                                            
           return 0;                                                  
        info->doubly_indirect = p;                                    
4000f138:	10 bf ff c1 	b  4000f03c <IMFS_memfile_get_block_pointer+0x13c>
4000f13c:	c2 26 20 5c 	st  %g1, [ %i0 + 0x5c ]                        
        info->triply_indirect = p;                                    
      }                                                               
                                                                      
      p1 = (block_p *) p[ triply ];                                   
      if ( !p1 ) {                                                    
        p1 = memfile_alloc_block();                                   
4000f140:	7f ff ff 63 	call  4000eecc <memfile_alloc_block>           
4000f144:	01 00 00 00 	nop                                            
        if ( !p1 )                                                    
4000f148:	84 92 20 00 	orcc  %o0, 0, %g2                              
4000f14c:	02 bf ff e6 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f150:	01 00 00 00 	nop                                            
           return 0;                                                  
        p[ triply ] = (block_p) p1;                                   
4000f154:	10 bf ff a3 	b  4000efe0 <IMFS_memfile_get_block_pointer+0xe0>
4000f158:	c4 26 c0 00 	st  %g2, [ %i3 ]                               
                                                                      
    p = info->triply_indirect;                                        
                                                                      
    if ( malloc_it ) {                                                
      if ( !p ) {                                                     
        p = memfile_alloc_block();                                    
4000f15c:	7f ff ff 5c 	call  4000eecc <memfile_alloc_block>           
4000f160:	01 00 00 00 	nop                                            
        if ( !p )                                                     
4000f164:	80 a2 20 00 	cmp  %o0, 0                                    
4000f168:	02 bf ff df 	be  4000f0e4 <IMFS_memfile_get_block_pointer+0x1e4><== NEVER TAKEN
4000f16c:	01 00 00 00 	nop                                            
           return 0;                                                  
        info->triply_indirect = p;                                    
4000f170:	10 bf ff 97 	b  4000efcc <IMFS_memfile_get_block_pointer+0xcc>
4000f174:	d0 26 20 60 	st  %o0, [ %i0 + 0x60 ]                        
                                                                      

4000f178 <IMFS_memfile_read>: IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) {
4000f178:	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;                                    
4000f17c:	c2 06 20 4c 	ld  [ %i0 + 0x4c ], %g1                        
4000f180:	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 ) {                 
4000f184:	c2 00 40 00 	ld  [ %g1 ], %g1                               
   IMFS_jnode_t    *the_jnode,                                        
   off_t            start,                                            
   unsigned char   *destination,                                      
   unsigned int     length                                            
)                                                                     
{                                                                     
4000f188:	a0 10 00 19 	mov  %i1, %l0                                  
4000f18c:	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 ) {                 
4000f190:	80 a0 60 05 	cmp  %g1, 5                                    
4000f194:	02 80 00 68 	be  4000f334 <IMFS_memfile_read+0x1bc>         
4000f198:	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 )                        
4000f19c:	c4 06 20 50 	ld  [ %i0 + 0x50 ], %g2                        
4000f1a0:	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;                                         
4000f1a4:	82 10 00 1a 	mov  %i2, %g1                                  
  if ( last_byte > the_jnode->info.file.size )                        
4000f1a8:	c8 06 20 54 	ld  [ %i0 + 0x54 ], %g4                        
4000f1ac:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000f1b0:	04 80 00 42 	ble  4000f2b8 <IMFS_memfile_read+0x140>        <== ALWAYS TAKEN
4000f1b4:	ba 07 00 1a 	add  %i4, %i2, %i5                             
    my_length = the_jnode->info.file.size - start;                    
4000f1b8:	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;                
4000f1bc:	33 10 00 7f 	sethi  %hi(0x4001fc00), %i1                    <== NOT EXECUTED
4000f1c0:	fa 06 61 28 	ld  [ %i1 + 0x128 ], %i5	! 4001fd28 <imfs_memfile_bytes_per_block>
4000f1c4:	90 10 00 10 	mov  %l0, %o0                                  
4000f1c8:	b7 3f 60 1f 	sra  %i5, 0x1f, %i3                            
4000f1cc:	96 10 00 1d 	mov  %i5, %o3                                  
4000f1d0:	94 10 00 1b 	mov  %i3, %o2                                  
4000f1d4:	40 00 2c 6b 	call  4001a380 <__moddi3>                      
4000f1d8:	92 10 00 11 	mov  %l1, %o1                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
4000f1dc:	90 10 00 10 	mov  %l0, %o0                                  
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
4000f1e0:	a8 10 00 09 	mov  %o1, %l4                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
4000f1e4:	94 10 00 1b 	mov  %i3, %o2                                  
4000f1e8:	92 10 00 11 	mov  %l1, %o1                                  
4000f1ec:	40 00 2b 7a 	call  40019fd4 <__divdi3>                      
4000f1f0:	96 10 00 1d 	mov  %i5, %o3                                  
  if ( start_offset )  {                                              
4000f1f4:	80 a5 20 00 	cmp  %l4, 0                                    
4000f1f8:	02 80 00 37 	be  4000f2d4 <IMFS_memfile_read+0x15c>         
4000f1fc:	b4 10 00 09 	mov  %o1, %i2                                  
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
4000f200:	ba 27 40 14 	sub  %i5, %l4, %i5                             
4000f204:	80 a7 00 1d 	cmp  %i4, %i5                                  
4000f208:	18 80 00 59 	bgu  4000f36c <IMFS_memfile_read+0x1f4>        
4000f20c:	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 );
4000f210:	90 10 00 12 	mov  %l2, %o0                                  
4000f214:	92 10 00 1a 	mov  %i2, %o1                                  
4000f218:	94 10 20 00 	clr  %o2                                       
4000f21c:	7f ff ff 39 	call  4000ef00 <IMFS_memfile_get_block_pointer>
4000f220:	b0 10 20 00 	clr  %i0                                       
    if ( !block_ptr )                                                 
4000f224:	80 a2 20 00 	cmp  %o0, 0                                    
4000f228:	02 80 00 22 	be  4000f2b0 <IMFS_memfile_read+0x138>         <== NEVER TAKEN
4000f22c:	94 10 00 10 	mov  %l0, %o2                                  
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );           
4000f230:	d2 02 00 00 	ld  [ %o0 ], %o1                               
4000f234:	90 10 00 13 	mov  %l3, %o0                                  
4000f238:	40 00 08 13 	call  40011284 <memcpy>                        
4000f23c:	92 02 40 14 	add  %o1, %l4, %o1                             
4000f240:	fa 06 61 28 	ld  [ %i1 + 0x128 ], %i5                       
    dest += to_copy;                                                  
4000f244:	b6 04 c0 10 	add  %l3, %l0, %i3                             
    block++;                                                          
4000f248:	b4 06 a0 01 	inc  %i2                                       
    my_length -= to_copy;                                             
4000f24c:	b8 27 00 10 	sub  %i4, %l0, %i4                             
    copied += to_copy;                                                
4000f250:	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 ) {               
4000f254:	80 a7 00 1d 	cmp  %i4, %i5                                  
4000f258:	1a 80 00 0e 	bcc  4000f290 <IMFS_memfile_read+0x118>        
4000f25c:	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 ) {                                                  
4000f260:	10 80 00 21 	b  4000f2e4 <IMFS_memfile_read+0x16c>          
4000f264:	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 );                      
4000f268:	d2 00 40 00 	ld  [ %g1 ], %o1                               
4000f26c:	40 00 08 06 	call  40011284 <memcpy>                        
4000f270:	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 ) {               
4000f274:	c2 06 61 28 	ld  [ %i1 + 0x128 ], %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;                                                  
4000f278:	b6 06 c0 1d 	add  %i3, %i5, %i3                             
    block++;                                                          
4000f27c:	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 ) {               
4000f280:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000f284:	18 80 00 17 	bgu  4000f2e0 <IMFS_memfile_read+0x168>        
4000f288:	b0 06 00 1d 	add  %i0, %i5, %i0                             
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f28c:	94 10 20 00 	clr  %o2                                       
4000f290:	92 10 00 1a 	mov  %i2, %o1                                  
4000f294:	7f ff ff 1b 	call  4000ef00 <IMFS_memfile_get_block_pointer>
4000f298:	90 10 00 12 	mov  %l2, %o0                                  
    if ( !block_ptr )                                                 
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], to_copy );                      
4000f29c:	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 );
4000f2a0:	82 10 00 08 	mov  %o0, %g1                                  
    if ( !block_ptr )                                                 
4000f2a4:	80 a0 60 00 	cmp  %g1, 0                                    
4000f2a8:	12 bf ff f0 	bne  4000f268 <IMFS_memfile_read+0xf0>         <== ALWAYS TAKEN
4000f2ac:	90 10 00 1b 	mov  %i3, %o0                                  
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
                                                                      
  return copied;                                                      
}                                                                     
4000f2b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f2b4:	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 )                        
4000f2b8:	12 bf ff c2 	bne  4000f1c0 <IMFS_memfile_read+0x48>         <== NEVER TAKEN
4000f2bc:	33 10 00 7f 	sethi  %hi(0x4001fc00), %i1                    
4000f2c0:	80 a7 40 04 	cmp  %i5, %g4                                  
4000f2c4:	08 bf ff c0 	bleu  4000f1c4 <IMFS_memfile_read+0x4c>        
4000f2c8:	fa 06 61 28 	ld  [ %i1 + 0x128 ], %i5                       
    my_length = the_jnode->info.file.size - start;                    
4000f2cc:	10 bf ff bd 	b  4000f1c0 <IMFS_memfile_read+0x48>           
4000f2d0:	b8 21 00 01 	sub  %g4, %g1, %i4                             
  unsigned int         last_byte;                                     
  unsigned int         copied;                                        
  unsigned int         start_offset;                                  
  unsigned char       *dest;                                          
                                                                      
  dest = destination;                                                 
4000f2d4:	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;                                                         
4000f2d8:	10 bf ff df 	b  4000f254 <IMFS_memfile_read+0xdc>           
4000f2dc:	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 ) {                                                  
4000f2e0:	80 a7 20 00 	cmp  %i4, 0                                    
4000f2e4:	02 80 00 0e 	be  4000f31c <IMFS_memfile_read+0x1a4>         
4000f2e8:	90 07 bf f8 	add  %fp, -8, %o0                              
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f2ec:	90 10 00 12 	mov  %l2, %o0                                  
4000f2f0:	92 10 00 1a 	mov  %i2, %o1                                  
4000f2f4:	7f ff ff 03 	call  4000ef00 <IMFS_memfile_get_block_pointer>
4000f2f8:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
4000f2fc:	80 a2 20 00 	cmp  %o0, 0                                    
4000f300:	02 bf ff ec 	be  4000f2b0 <IMFS_memfile_read+0x138>         <== NEVER TAKEN
4000f304:	94 10 00 1c 	mov  %i4, %o2                                  
      return copied;                                                  
    memcpy( dest, &(*block_ptr)[ 0 ], my_length );                    
4000f308:	d2 02 00 00 	ld  [ %o0 ], %o1                               
4000f30c:	90 10 00 1b 	mov  %i3, %o0                                  
4000f310:	40 00 07 dd 	call  40011284 <memcpy>                        
4000f314:	b0 06 00 1c 	add  %i0, %i4, %i0                             
    copied += my_length;                                              
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
4000f318:	90 07 bf f8 	add  %fp, -8, %o0                              
4000f31c:	7f ff d3 e5 	call  400042b0 <gettimeofday>                  
4000f320:	92 10 20 00 	clr  %o1                                       
4000f324:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000f328:	c2 24 a0 40 	st  %g1, [ %l2 + 0x40 ]                        
                                                                      
  return copied;                                                      
}                                                                     
4000f32c:	81 c7 e0 08 	ret                                            
4000f330:	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))        
4000f334:	f4 1e 20 50 	ldd  [ %i0 + 0x50 ], %i2                       
4000f338:	82 10 20 00 	clr  %g1                                       
4000f33c:	86 a6 c0 11 	subcc  %i3, %l1, %g3                           
4000f340:	84 66 80 19 	subx  %i2, %i1, %g2                            
4000f344:	80 a0 40 02 	cmp  %g1, %g2                                  
4000f348:	04 80 00 0b 	ble  4000f374 <IMFS_memfile_read+0x1fc>        <== ALWAYS TAKEN
4000f34c:	d2 06 20 58 	ld  [ %i0 + 0x58 ], %o1                        
      my_length = the_jnode->info.linearfile.size - start;            
4000f350:	b0 26 c0 11 	sub  %i3, %l1, %i0                             <== NOT EXECUTED
                                                                      
    memcpy(dest, &file_ptr[start], my_length);                        
4000f354:	92 02 40 11 	add  %o1, %l1, %o1                             
4000f358:	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 );                    
4000f35c:	40 00 07 ca 	call  40011284 <memcpy>                        
4000f360:	90 10 00 13 	mov  %l3, %o0                                  
    copied += my_length;                                              
  }                                                                   
                                                                      
  IMFS_update_atime( the_jnode );                                     
4000f364:	10 bf ff ee 	b  4000f31c <IMFS_memfile_read+0x1a4>          
4000f368:	90 07 bf f8 	add  %fp, -8, %o0                              
4000f36c:	10 bf ff a9 	b  4000f210 <IMFS_memfile_read+0x98>           
4000f370:	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))        
4000f374:	12 80 00 04 	bne  4000f384 <IMFS_memfile_read+0x20c>        <== NEVER TAKEN
4000f378:	80 a7 00 03 	cmp  %i4, %g3                                  
4000f37c:	38 bf ff f6 	bgu,a   4000f354 <IMFS_memfile_read+0x1dc>     <== ALWAYS TAKEN
4000f380:	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;                                                 
4000f384:	10 bf ff f4 	b  4000f354 <IMFS_memfile_read+0x1dc>          <== NOT EXECUTED
4000f388:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
                                                                      

4000f49c <IMFS_memfile_remove>: * is better to stick to simple, easy to understand algorithms. */ IMFS_jnode_t *IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) {
4000f49c:	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;                                 
4000f4a0:	39 10 00 7f 	sethi  %hi(0x4001fc00), %i4                    
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
4000f4a4:	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;                                 
4000f4a8:	f4 07 21 28 	ld  [ %i4 + 0x128 ], %i2                       
   *    + doubly indirect                                             
   *    + triply indirect                                             
   */                                                                 
  info = &the_jnode->info.file;                                       
                                                                      
  if ( info->indirect ) {                                             
4000f4ac:	80 a0 60 00 	cmp  %g1, 0                                    
4000f4b0:	02 80 00 05 	be  4000f4c4 <IMFS_memfile_remove+0x28>        
4000f4b4:	b5 36 a0 02 	srl  %i2, 2, %i2                               
    memfile_free_blocks_in_table( &info->indirect, to_free );         
4000f4b8:	90 06 20 58 	add  %i0, 0x58, %o0                            
4000f4bc:	7f ff ff e2 	call  4000f444 <memfile_free_blocks_in_table>  
4000f4c0:	92 10 00 1a 	mov  %i2, %o1                                  
  }                                                                   
                                                                      
  if ( info->doubly_indirect ) {                                      
4000f4c4:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
4000f4c8:	80 a0 60 00 	cmp  %g1, 0                                    
4000f4cc:	02 80 00 1b 	be  4000f538 <IMFS_memfile_remove+0x9c>        
4000f4d0:	c4 07 21 28 	ld  [ %i4 + 0x128 ], %g2                       
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
4000f4d4:	85 30 a0 02 	srl  %g2, 2, %g2                               
4000f4d8:	80 a0 a0 00 	cmp  %g2, 0                                    
4000f4dc:	02 80 00 14 	be  4000f52c <IMFS_memfile_remove+0x90>        <== NEVER TAKEN
4000f4e0:	90 10 20 00 	clr  %o0                                       
4000f4e4:	37 10 00 7f 	sethi  %hi(0x4001fc00), %i3                    
4000f4e8:	ba 10 20 00 	clr  %i5                                       
4000f4ec:	10 80 00 03 	b  4000f4f8 <IMFS_memfile_remove+0x5c>         
4000f4f0:	b6 16 e1 28 	or  %i3, 0x128, %i3                            
4000f4f4:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
      if ( info->doubly_indirect[i] ) {                               
4000f4f8:	91 2a 20 02 	sll  %o0, 2, %o0                               
4000f4fc:	c4 00 40 08 	ld  [ %g1 + %o0 ], %g2                         
4000f500:	80 a0 a0 00 	cmp  %g2, 0                                    
4000f504:	02 80 00 04 	be  4000f514 <IMFS_memfile_remove+0x78>        <== NEVER TAKEN
4000f508:	90 00 40 08 	add  %g1, %o0, %o0                             
        memfile_free_blocks_in_table(                                 
4000f50c:	7f ff ff ce 	call  4000f444 <memfile_free_blocks_in_table>  
4000f510:	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++ ) {                  
4000f514:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4000f518:	ba 07 60 01 	inc  %i5                                       
4000f51c:	83 30 60 02 	srl  %g1, 2, %g1                               
4000f520:	80 a7 40 01 	cmp  %i5, %g1                                  
4000f524:	0a bf ff f4 	bcs  4000f4f4 <IMFS_memfile_remove+0x58>       
4000f528:	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 );  
4000f52c:	90 06 20 5c 	add  %i0, 0x5c, %o0                            
4000f530:	7f ff ff c5 	call  4000f444 <memfile_free_blocks_in_table>  
4000f534:	92 10 00 1a 	mov  %i2, %o1                                  
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
4000f538:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        
4000f53c:	80 a2 20 00 	cmp  %o0, 0                                    
4000f540:	02 80 00 33 	be  4000f60c <IMFS_memfile_remove+0x170>       
4000f544:	c4 07 21 28 	ld  [ %i4 + 0x128 ], %g2                       
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
4000f548:	85 30 a0 02 	srl  %g2, 2, %g2                               
4000f54c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000f550:	22 80 00 2d 	be,a   4000f604 <IMFS_memfile_remove+0x168>    <== NEVER TAKEN
4000f554:	90 06 20 60 	add  %i0, 0x60, %o0                            <== NOT EXECUTED
      p = (block_p *) info->triply_indirect[i];                       
4000f558:	f8 02 00 00 	ld  [ %o0 ], %i4                               
      if ( !p )  /* ensure we have a valid pointer */                 
4000f55c:	80 a7 20 00 	cmp  %i4, 0                                    
4000f560:	22 80 00 29 	be,a   4000f604 <IMFS_memfile_remove+0x168>    <== NEVER TAKEN
4000f564:	90 06 20 60 	add  %i0, 0x60, %o0                            <== NOT EXECUTED
4000f568:	37 10 00 7f 	sethi  %hi(0x4001fc00), %i3                    
                                                                      
  }                                                                   
                                                                      
  if ( info->triply_indirect ) {                                      
    for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {                  
      p = (block_p *) info->triply_indirect[i];                       
4000f56c:	a0 10 20 00 	clr  %l0                                       
      if ( !p )  /* ensure we have a valid pointer */                 
4000f570:	b2 10 20 00 	clr  %i1                                       
4000f574:	b6 16 e1 28 	or  %i3, 0x128, %i3                            
         break;                                                       
      for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {                
4000f578:	80 a0 a0 00 	cmp  %g2, 0                                    
4000f57c:	22 80 00 13 	be,a   4000f5c8 <IMFS_memfile_remove+0x12c>    <== NEVER TAKEN
4000f580:	90 02 00 10 	add  %o0, %l0, %o0                             <== NOT EXECUTED
4000f584:	90 10 20 00 	clr  %o0                                       
4000f588:	ba 10 20 00 	clr  %i5                                       
        if ( p[j] ) {                                                 
4000f58c:	91 2a 20 02 	sll  %o0, 2, %o0                               
4000f590:	c2 07 00 08 	ld  [ %i4 + %o0 ], %g1                         
4000f594:	80 a0 60 00 	cmp  %g1, 0                                    
4000f598:	02 80 00 04 	be  4000f5a8 <IMFS_memfile_remove+0x10c>       <== NEVER TAKEN
4000f59c:	90 07 00 08 	add  %i4, %o0, %o0                             
          memfile_free_blocks_in_table( (block_p **)&p[j], to_free);  
4000f5a0:	7f ff ff a9 	call  4000f444 <memfile_free_blocks_in_table>  
4000f5a4:	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++ ) {                
4000f5a8:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4000f5ac:	ba 07 60 01 	inc  %i5                                       
4000f5b0:	83 30 60 02 	srl  %g1, 2, %g1                               
4000f5b4:	80 a7 40 01 	cmp  %i5, %g1                                  
4000f5b8:	0a bf ff f5 	bcs  4000f58c <IMFS_memfile_remove+0xf0>       
4000f5bc:	90 10 00 1d 	mov  %i5, %o0                                  
4000f5c0:	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(                                   
4000f5c4:	90 02 00 10 	add  %o0, %l0, %o0                             
4000f5c8:	7f ff ff 9f 	call  4000f444 <memfile_free_blocks_in_table>  
4000f5cc:	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++ ) {                  
4000f5d0:	c4 06 c0 00 	ld  [ %i3 ], %g2                               
4000f5d4:	b2 06 60 01 	inc  %i1                                       
4000f5d8:	85 30 a0 02 	srl  %g2, 2, %g2                               
4000f5dc:	80 a6 40 02 	cmp  %i1, %g2                                  
4000f5e0:	1a 80 00 09 	bcc  4000f604 <IMFS_memfile_remove+0x168>      
4000f5e4:	90 06 20 60 	add  %i0, 0x60, %o0                            
      p = (block_p *) info->triply_indirect[i];                       
4000f5e8:	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(                                    
4000f5ec:	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];                       
4000f5f0:	f8 02 00 10 	ld  [ %o0 + %l0 ], %i4                         
      if ( !p )  /* ensure we have a valid pointer */                 
4000f5f4:	80 a7 20 00 	cmp  %i4, 0                                    
4000f5f8:	12 bf ff e1 	bne  4000f57c <IMFS_memfile_remove+0xe0>       <== ALWAYS TAKEN
4000f5fc:	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(                                     
4000f600:	90 06 20 60 	add  %i0, 0x60, %o0                            <== NOT EXECUTED
4000f604:	7f ff ff 90 	call  4000f444 <memfile_free_blocks_in_table>  
4000f608:	92 10 00 1a 	mov  %i2, %o1                                  
        (block_p **)&info->triply_indirect, to_free );                
  }                                                                   
                                                                      
  return the_jnode;                                                   
}                                                                     
4000f60c:	81 c7 e0 08 	ret                                            
4000f610:	81 e8 00 00 	restore                                        
                                                                      

4000f614 <IMFS_memfile_remove_block>: */ MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) {
4000f614:	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 );  
4000f618:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000f61c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000f620:	7f ff fe 38 	call  4000ef00 <IMFS_memfile_get_block_pointer><== NOT EXECUTED
4000f624:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4000f628:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
  IMFS_assert( block_ptr );                                           
                                                                      
  ptr = *block_ptr;                                                   
4000f62c:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
  *block_ptr = 0;                                                     
  memfile_free_block( ptr );                                          
                                                                      
  return 1;                                                           
}                                                                     
4000f630:	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 );                                          
4000f634:	7f ff ff 7b 	call  4000f420 <memfile_free_block>            <== NOT EXECUTED
4000f638:	c0 20 40 00 	clr  [ %g1 ]                                   <== NOT EXECUTED
                                                                      
  return 1;                                                           
}                                                                     
4000f63c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f640:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000f808 <IMFS_memfile_write>: IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) {
4000f808:	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 ) {                      
4000f80c:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        
4000f810:	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;                                      
4000f814:	96 07 00 1a 	add  %i4, %i2, %o3                             
  if ( last_byte > the_jnode->info.file.size ) {                      
4000f818:	80 a0 80 01 	cmp  %g2, %g1                                  
4000f81c:	14 80 00 5e 	bg  4000f994 <IMFS_memfile_write+0x18c>        <== NEVER TAKEN
4000f820:	c6 06 20 54 	ld  [ %i0 + 0x54 ], %g3                        
4000f824:	80 a0 80 01 	cmp  %g2, %g1                                  
4000f828:	02 80 00 59 	be  4000f98c <IMFS_memfile_write+0x184>        <== ALWAYS TAKEN
4000f82c:	80 a2 c0 03 	cmp  %o3, %g3                                  
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
4000f830:	21 10 00 7f 	sethi  %hi(0x4001fc00), %l0                    <== NOT EXECUTED
4000f834:	fa 04 21 28 	ld  [ %l0 + 0x128 ], %i5	! 4001fd28 <imfs_memfile_bytes_per_block>
4000f838:	90 10 00 19 	mov  %i1, %o0                                  
4000f83c:	a3 3f 60 1f 	sra  %i5, 0x1f, %l1                            
4000f840:	92 10 00 1a 	mov  %i2, %o1                                  
4000f844:	94 10 00 11 	mov  %l1, %o2                                  
4000f848:	40 00 2a ce 	call  4001a380 <__moddi3>                      
4000f84c:	96 10 00 1d 	mov  %i5, %o3                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
4000f850:	90 10 00 19 	mov  %i1, %o0                                  
   */                                                                 
                                                                      
  /*                                                                  
   *  Phase 1: possibly the last part of one block                    
   */                                                                 
  start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;                
4000f854:	a4 10 00 09 	mov  %o1, %l2                                  
  block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;                       
4000f858:	94 10 00 11 	mov  %l1, %o2                                  
4000f85c:	92 10 00 1a 	mov  %i2, %o1                                  
4000f860:	40 00 29 dd 	call  40019fd4 <__divdi3>                      
4000f864:	96 10 00 1d 	mov  %i5, %o3                                  
    status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );  
    if ( status )                                                     
      return status;                                                  
  }                                                                   
                                                                      
  copied = 0;                                                         
4000f868:	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 )  {                                              
4000f86c:	80 a4 a0 00 	cmp  %l2, 0                                    
4000f870:	02 80 00 16 	be  4000f8c8 <IMFS_memfile_write+0xc0>         
4000f874:	b4 10 00 09 	mov  %o1, %i2                                  
    to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;            
4000f878:	b2 27 40 12 	sub  %i5, %l2, %i1                             
4000f87c:	80 a6 40 1c 	cmp  %i1, %i4                                  
4000f880:	38 80 00 02 	bgu,a   4000f888 <IMFS_memfile_write+0x80>     
4000f884:	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 );
4000f888:	90 10 00 18 	mov  %i0, %o0                                  
4000f88c:	92 10 00 1a 	mov  %i2, %o1                                  
4000f890:	7f ff fd 9c 	call  4000ef00 <IMFS_memfile_get_block_pointer>
4000f894:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
4000f898:	80 a2 20 00 	cmp  %o0, 0                                    
4000f89c:	02 80 00 22 	be  4000f924 <IMFS_memfile_write+0x11c>        <== NEVER TAKEN
4000f8a0:	82 10 20 00 	clr  %g1                                       
        block,                                                        
        to_copy,                                                      
        src                                                           
      );                                                              
    #endif                                                            
    memcpy( &(*block_ptr)[ start_offset ], src, to_copy );            
4000f8a4:	d0 02 00 00 	ld  [ %o0 ], %o0                               
4000f8a8:	92 10 00 1b 	mov  %i3, %o1                                  
4000f8ac:	90 02 00 12 	add  %o0, %l2, %o0                             
4000f8b0:	40 00 06 75 	call  40011284 <memcpy>                        
4000f8b4:	94 10 00 19 	mov  %i1, %o2                                  
4000f8b8:	fa 04 21 28 	ld  [ %l0 + 0x128 ], %i5                       
    src += to_copy;                                                   
4000f8bc:	b6 06 c0 19 	add  %i3, %i1, %i3                             
    block++;                                                          
4000f8c0:	b4 06 a0 01 	inc  %i2                                       
    my_length -= to_copy;                                             
4000f8c4:	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 ) {               
4000f8c8:	80 a7 00 1d 	cmp  %i4, %i5                                  
4000f8cc:	1a 80 00 0e 	bcc  4000f904 <IMFS_memfile_write+0xfc>        
4000f8d0:	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 ) {                                                  
4000f8d4:	10 80 00 17 	b  4000f930 <IMFS_memfile_write+0x128>         
4000f8d8:	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 );                       
4000f8dc:	d0 02 00 00 	ld  [ %o0 ], %o0                               
4000f8e0:	40 00 06 69 	call  40011284 <memcpy>                        
4000f8e4:	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 ) {               
4000f8e8:	c2 04 21 28 	ld  [ %l0 + 0x128 ], %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;                                                   
4000f8ec:	b6 06 c0 1d 	add  %i3, %i5, %i3                             
    block++;                                                          
4000f8f0:	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 ) {               
4000f8f4:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000f8f8:	18 80 00 0d 	bgu  4000f92c <IMFS_memfile_write+0x124>       
4000f8fc:	b2 06 40 1d 	add  %i1, %i5, %i1                             
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f900:	92 10 00 1a 	mov  %i2, %o1                                  
4000f904:	94 10 20 00 	clr  %o2                                       
4000f908:	7f ff fd 7e 	call  4000ef00 <IMFS_memfile_get_block_pointer>
4000f90c:	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 );                       
4000f910:	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 )                                                 
4000f914:	80 a2 20 00 	cmp  %o0, 0                                    
4000f918:	12 bf ff f1 	bne  4000f8dc <IMFS_memfile_write+0xd4>        <== ALWAYS TAKEN
4000f91c:	94 10 00 1d 	mov  %i5, %o2                                  
4000f920:	82 10 00 19 	mov  %i1, %g1                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
                                                                      
  return copied;                                                      
}                                                                     
4000f924:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f928:	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 ) {                                                  
4000f92c:	80 a7 20 00 	cmp  %i4, 0                                    
4000f930:	02 80 00 0f 	be  4000f96c <IMFS_memfile_write+0x164>        
4000f934:	90 07 bf f8 	add  %fp, -8, %o0                              
    block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
4000f938:	90 10 00 18 	mov  %i0, %o0                                  
4000f93c:	92 10 00 1a 	mov  %i2, %o1                                  
4000f940:	7f ff fd 70 	call  4000ef00 <IMFS_memfile_get_block_pointer>
4000f944:	94 10 20 00 	clr  %o2                                       
    if ( !block_ptr )                                                 
4000f948:	80 a2 20 00 	cmp  %o0, 0                                    
4000f94c:	02 bf ff f6 	be  4000f924 <IMFS_memfile_write+0x11c>        <== NEVER TAKEN
4000f950:	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 );                     
4000f954:	d0 02 00 00 	ld  [ %o0 ], %o0                               
4000f958:	92 10 00 1b 	mov  %i3, %o1                                  
4000f95c:	94 10 00 1c 	mov  %i4, %o2                                  
4000f960:	40 00 06 49 	call  40011284 <memcpy>                        
4000f964:	b2 06 40 1c 	add  %i1, %i4, %i1                             
    my_length = 0;                                                    
    copied += to_copy;                                                
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
4000f968:	90 07 bf f8 	add  %fp, -8, %o0                              
4000f96c:	7f ff d2 51 	call  400042b0 <gettimeofday>                  
4000f970:	92 10 20 00 	clr  %o1                                       
4000f974:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
                                                                      
  return copied;                                                      
4000f978:	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 );                               
4000f97c:	c4 26 20 44 	st  %g2, [ %i0 + 0x44 ]                        
4000f980:	c4 26 20 48 	st  %g2, [ %i0 + 0x48 ]                        
                                                                      
  return copied;                                                      
}                                                                     
4000f984:	81 c7 e0 08 	ret                                            
4000f988:	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 ) {                      
4000f98c:	08 bf ff aa 	bleu  4000f834 <IMFS_memfile_write+0x2c>       
4000f990:	21 10 00 7f 	sethi  %hi(0x4001fc00), %l0                    
    bool zero_fill = start > the_jnode->info.file.size;               
4000f994:	80 a6 40 01 	cmp  %i1, %g1                                  
4000f998:	04 80 00 0b 	ble  4000f9c4 <IMFS_memfile_write+0x1bc>       <== ALWAYS TAKEN
4000f99c:	92 10 20 01 	mov  1, %o1                                    
                                                                      
    status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );  
4000f9a0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000f9a4:	92 0a 60 01 	and  %o1, 1, %o1                               
4000f9a8:	7f ff ff 27 	call  4000f644 <IMFS_memfile_extend>           
4000f9ac:	94 10 20 00 	clr  %o2                                       
    if ( status )                                                     
4000f9b0:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000f9b4:	02 bf ff a0 	be  4000f834 <IMFS_memfile_write+0x2c>         
4000f9b8:	21 10 00 7f 	sethi  %hi(0x4001fc00), %l0                    
  }                                                                   
                                                                      
  IMFS_mtime_ctime_update( the_jnode );                               
                                                                      
  return copied;                                                      
}                                                                     
4000f9bc:	81 c7 e0 08 	ret                                            
4000f9c0:	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;               
4000f9c4:	02 80 00 0b 	be  4000f9f0 <IMFS_memfile_write+0x1e8>        <== ALWAYS TAKEN
4000f9c8:	80 a6 80 03 	cmp  %i2, %g3                                  
4000f9cc:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
                                                                      
    status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );  
4000f9d0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000f9d4:	92 0a 60 01 	and  %o1, 1, %o1                               
4000f9d8:	7f ff ff 1b 	call  4000f644 <IMFS_memfile_extend>           
4000f9dc:	94 10 20 00 	clr  %o2                                       
    if ( status )                                                     
4000f9e0:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000f9e4:	02 bf ff 94 	be  4000f834 <IMFS_memfile_write+0x2c>         
4000f9e8:	21 10 00 7f 	sethi  %hi(0x4001fc00), %l0                    
4000f9ec:	30 bf ff f4 	b,a   4000f9bc <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;               
4000f9f0:	18 bf ff ed 	bgu  4000f9a4 <IMFS_memfile_write+0x19c>       
4000f9f4:	90 10 00 18 	mov  %i0, %o0                                  
4000f9f8:	10 bf ff f7 	b  4000f9d4 <IMFS_memfile_write+0x1cc>         
4000f9fc:	92 10 20 00 	clr  %o1                                       
                                                                      

400039e4 <IMFS_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
400039e4:	9d e3 bf 80 	save  %sp, -128, %sp                           
  dev_t dev,                                                          
  IMFS_jnode_types_t *type,                                           
  IMFS_types_union *info                                              
)                                                                     
{                                                                     
  if ( S_ISDIR( mode ) ) {                                            
400039e8:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
400039ec:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
400039f0:	82 0e c0 01 	and  %i3, %g1, %g1                             
400039f4:	80 a0 40 02 	cmp  %g1, %g2                                  
400039f8:	02 80 00 2b 	be  40003aa4 <IMFS_mknod+0xc0>                 
400039fc:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
    *type = IMFS_DIRECTORY;                                           
  } else if ( S_ISREG( mode ) ) {                                     
40003a00:	80 a0 40 02 	cmp  %g1, %g2                                  
40003a04:	02 80 00 2a 	be  40003aac <IMFS_mknod+0xc8>                 
40003a08:	09 00 00 2c 	sethi  %hi(0xb000), %g4                        
    *type = IMFS_MEMORY_FILE;                                         
  } else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {                  
40003a0c:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
40003a10:	88 0e c0 04 	and  %i3, %g4, %g4                             
40003a14:	80 a1 00 02 	cmp  %g4, %g2                                  
40003a18:	02 80 00 07 	be  40003a34 <IMFS_mknod+0x50>                 
40003a1c:	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 )) {                                      
40003a20:	80 a0 40 02 	cmp  %g1, %g2                                  
40003a24:	22 80 00 06 	be,a   40003a3c <IMFS_mknod+0x58>              <== ALWAYS TAKEN
40003a28:	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 =                                     
40003a2c:	10 80 00 05 	b  40003a40 <IMFS_mknod+0x5c>                  <== NOT EXECUTED
40003a30:	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(                                     
40003a34:	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;                                              
40003a38:	86 10 20 01 	mov  1, %g3                                    
40003a3c:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
    (const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;            
                                                                      
  return IMFS_create_node_with_control(                               
40003a40:	82 00 e0 02 	add  %g3, 2, %g1                               
40003a44:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
40003a48:	83 28 60 02 	sll  %g1, 2, %g1                               
40003a4c:	d2 00 80 01 	ld  [ %g2 + %g1 ], %o1                         
40003a50:	90 10 00 18 	mov  %i0, %o0                                  
40003a54:	94 10 00 19 	mov  %i1, %o2                                  
40003a58:	96 10 00 1a 	mov  %i2, %o3                                  
40003a5c:	98 10 00 1b 	mov  %i3, %o4                                  
40003a60:	40 00 23 57 	call  4000c7bc <IMFS_create_node_with_control> 
40003a64:	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 ) {                                           
40003a68:	80 a2 20 00 	cmp  %o0, 0                                    
40003a6c:	02 80 00 12 	be  40003ab4 <IMFS_mknod+0xd0>                 
40003a70:	92 10 20 00 	clr  %o1                                       
    IMFS_jnode_t *parent = parentloc->node_access;                    
40003a74:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
                                                                      
    IMFS_update_ctime( parent );                                      
40003a78:	40 00 02 0e 	call  400042b0 <gettimeofday>                  
40003a7c:	90 07 bf e0 	add  %fp, -32, %o0                             
40003a80:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
    IMFS_update_mtime( parent );                                      
40003a84:	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 );                                      
40003a88:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
    IMFS_update_mtime( parent );                                      
40003a8c:	40 00 02 09 	call  400042b0 <gettimeofday>                  
40003a90:	92 10 20 00 	clr  %o1                                       
40003a94:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
40003a98:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        
  size_t namelen,                                                     
  mode_t mode,                                                        
  dev_t dev                                                           
)                                                                     
{                                                                     
  int rv = 0;                                                         
40003a9c:	81 c7 e0 08 	ret                                            
40003aa0:	91 e8 20 00 	restore  %g0, 0, %o0                           
  IMFS_jnode_types_t *type,                                           
  IMFS_types_union *info                                              
)                                                                     
{                                                                     
  if ( S_ISDIR( mode ) ) {                                            
    *type = IMFS_DIRECTORY;                                           
40003aa4:	10 bf ff e6 	b  40003a3c <IMFS_mknod+0x58>                  
40003aa8:	86 10 20 00 	clr  %g3                                       
  } else if ( S_ISREG( mode ) ) {                                     
    *type = IMFS_MEMORY_FILE;                                         
40003aac:	10 bf ff e4 	b  40003a3c <IMFS_mknod+0x58>                  
40003ab0:	86 10 20 04 	mov  4, %g3                                    
  } else {                                                            
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003ab4:	81 c7 e0 08 	ret                                            
40003ab8:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

40003abc <IMFS_mount>: #endif #include "imfs.h" int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
40003abc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access; 
40003ac0:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
40003ac4:	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;                  
40003ac8:	c4 00 60 4c 	ld  [ %g1 + 0x4c ], %g2                        
                                                                      
  if ( IMFS_is_directory( node ) ) {                                  
40003acc:	c4 00 80 00 	ld  [ %g2 ], %g2                               
40003ad0:	80 a0 a0 00 	cmp  %g2, 0                                    
40003ad4:	12 80 00 0f 	bne  40003b10 <IMFS_mount+0x54>                
40003ad8:	01 00 00 00 	nop                                            
    if ( node->info.directory.mt_fs == NULL ) {                       
40003adc:	c4 00 60 5c 	ld  [ %g1 + 0x5c ], %g2                        
40003ae0:	80 a0 a0 00 	cmp  %g2, 0                                    
40003ae4:	12 80 00 05 	bne  40003af8 <IMFS_mount+0x3c>                <== NEVER TAKEN
40003ae8:	01 00 00 00 	nop                                            
      node->info.directory.mt_fs = mt_entry;                          
40003aec:	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;                                                         
40003af0:	81 c7 e0 08 	ret                                            
40003af4:	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;                                                  
40003af8:	40 00 33 92 	call  40010940 <__errno>                       <== NOT EXECUTED
40003afc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40003b00:	82 10 20 10 	mov  0x10, %g1                                 <== NOT EXECUTED
40003b04:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40003b08:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003b0c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = ENOTDIR;                                                  
40003b10:	40 00 33 8c 	call  40010940 <__errno>                       
40003b14:	b0 10 3f ff 	mov  -1, %i0                                   
40003b18:	82 10 20 14 	mov  0x14, %g1                                 
40003b1c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003b20:	81 c7 e0 08 	ret                                            
40003b24:	81 e8 00 00 	restore                                        
                                                                      

4000cc4c <IMFS_node_remove_directory>: } static IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node ) {
4000cc4c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {     
4000cc50:	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 );                            
4000cc54:	82 06 20 54 	add  %i0, 0x54, %g1                            
4000cc58:	80 a0 80 01 	cmp  %g2, %g1                                  
4000cc5c:	12 80 00 08 	bne  4000cc7c <IMFS_node_remove_directory+0x30>
4000cc60:	01 00 00 00 	nop                                            
    errno = ENOTEMPTY;                                                
    node = NULL;                                                      
  } else if ( IMFS_is_mount_point( node ) ) {                         
4000cc64:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
4000cc68:	80 a0 60 00 	cmp  %g1, 0                                    
4000cc6c:	12 80 00 0a 	bne  4000cc94 <IMFS_node_remove_directory+0x48><== NEVER TAKEN
4000cc70:	01 00 00 00 	nop                                            
    errno = EBUSY;                                                    
    node = NULL;                                                      
  }                                                                   
                                                                      
  return node;                                                        
}                                                                     
4000cc74:	81 c7 e0 08 	ret                                            
4000cc78:	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;                                                
4000cc7c:	40 00 0f 31 	call  40010940 <__errno>                       
4000cc80:	b0 10 20 00 	clr  %i0                                       
4000cc84:	82 10 20 5a 	mov  0x5a, %g1                                 
4000cc88:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000cc8c:	81 c7 e0 08 	ret                                            
4000cc90:	81 e8 00 00 	restore                                        
    node = NULL;                                                      
  } else if ( IMFS_is_mount_point( node ) ) {                         
    errno = EBUSY;                                                    
4000cc94:	40 00 0f 2b 	call  40010940 <__errno>                       <== NOT EXECUTED
4000cc98:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4000cc9c:	82 10 20 10 	mov  0x10, %g1                                 <== NOT EXECUTED
4000cca0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    node = NULL;                                                      
  }                                                                   
                                                                      
  return node;                                                        
}                                                                     
4000cca4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000cca8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40003b28 <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;
40003b28:	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;                                    
40003b2c:	c2 00 a0 4c 	ld  [ %g2 + 0x4c ], %g1                        
40003b30:	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 ) {                                              
40003b34:	80 a0 60 02 	cmp  %g1, 2                                    
40003b38:	02 80 00 06 	be  40003b50 <IMFS_node_type+0x28>             
40003b3c:	80 a0 60 05 	cmp  %g1, 5                                    
40003b40:	02 80 00 08 	be  40003b60 <IMFS_node_type+0x38>             <== NEVER TAKEN
40003b44:	90 10 20 04 	mov  4, %o0                                    
      type = imfs_type;                                               
      break;                                                          
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
40003b48:	81 c3 e0 08 	retl                                           
40003b4c:	90 10 00 01 	mov  %g1, %o0                                  
40003b50:	c2 00 a0 50 	ld  [ %g2 + 0x50 ], %g1                        
40003b54:	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;                                                          
40003b58:	81 c3 e0 08 	retl                                           
40003b5c:	d0 00 40 00 	ld  [ %g1 ], %o0                               
40003b60:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

40003b68 <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++ )
40003b68:	80 a2 a0 00 	cmp  %o2, 0                                    
40003b6c:	02 80 00 16 	be  40003bc4 <IMFS_readlink+0x5c>              <== NEVER TAKEN
40003b70:	c8 02 20 08 	ld  [ %o0 + 8 ], %g4                           
40003b74:	c2 01 20 50 	ld  [ %g4 + 0x50 ], %g1                        
40003b78:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
40003b7c:	80 a0 a0 00 	cmp  %g2, 0                                    
40003b80:	02 80 00 11 	be  40003bc4 <IMFS_readlink+0x5c>              <== NEVER TAKEN
40003b84:	c2 08 40 00 	ldub  [ %g1 ], %g1                             
40003b88:	84 10 20 00 	clr  %g2                                       
40003b8c:	10 80 00 07 	b  40003ba8 <IMFS_readlink+0x40>               
40003b90:	90 10 20 00 	clr  %o0                                       
40003b94:	c2 01 20 50 	ld  [ %g4 + 0x50 ], %g1                        
40003b98:	c6 48 40 08 	ldsb  [ %g1 + %o0 ], %g3                       
40003b9c:	80 a0 e0 00 	cmp  %g3, 0                                    
40003ba0:	02 80 00 07 	be  40003bbc <IMFS_readlink+0x54>              
40003ba4:	c2 08 40 08 	ldub  [ %g1 + %o0 ], %g1                       
    buf[i] = node->info.sym_link.name[i];                             
40003ba8:	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++ )
40003bac:	90 02 20 01 	inc  %o0                                       
40003bb0:	80 a2 00 0a 	cmp  %o0, %o2                                  
40003bb4:	12 bf ff f8 	bne  40003b94 <IMFS_readlink+0x2c>             
40003bb8:	84 10 00 08 	mov  %o0, %g2                                  
    buf[i] = node->info.sym_link.name[i];                             
                                                                      
  return i;                                                           
}                                                                     
40003bbc:	81 c3 e0 08 	retl                                           
40003bc0:	01 00 00 00 	nop                                            
40003bc4:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40003bc8:	90 10 20 00 	clr  %o0	! 0 <PROM_START>                      <== NOT EXECUTED
                                                                      

40003bcc <IMFS_rename>: const rtems_filesystem_location_info_t *oldloc, const rtems_filesystem_location_info_t *newparentloc, const char *name, size_t namelen ) {
40003bcc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int rv = 0;                                                         
  IMFS_jnode_t *node = oldloc->node_access;                           
40003bd0:	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 ) {                                       
40003bd4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40003bd8:	80 a0 60 00 	cmp  %g1, 0                                    
40003bdc:	02 80 00 22 	be  40003c64 <IMFS_rename+0x98>                <== NEVER TAKEN
40003be0:	f4 06 a0 08 	ld  [ %i2 + 8 ], %i2                           
    if ( namelen < IMFS_NAME_MAX ) {                                  
40003be4:	80 a7 20 1f 	cmp  %i4, 0x1f                                 
40003be8:	18 80 00 19 	bgu  40003c4c <IMFS_rename+0x80>               <== NEVER TAKEN
40003bec:	94 10 00 1c 	mov  %i4, %o2                                  
      memcpy( node->name, name, namelen );                            
40003bf0:	92 10 00 1b 	mov  %i3, %o1                                  
40003bf4:	40 00 35 a4 	call  40011284 <memcpy>                        
40003bf8:	90 07 60 0c 	add  %i5, 0xc, %o0                             
      node->name [namelen] = '\0';                                    
40003bfc:	b8 07 40 1c 	add  %i5, %i4, %i4                             
40003c00:	c0 2f 20 0c 	clrb  [ %i4 + 0xc ]                            
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
40003c04:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
40003c08:	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 );                        
40003c0c:	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;                                          
40003c10:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
40003c14:	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;                              
40003c18:	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;                                                 
40003c1c:	f4 27 60 08 	st  %i2, [ %i5 + 8 ]                           
                                                                      
  the_node->next = tail;                                              
40003c20:	c6 27 40 00 	st  %g3, [ %i5 ]                               
  tail->previous = the_node;                                          
40003c24:	fa 26 a0 58 	st  %i5, [ %i2 + 0x58 ]                        
  old_last->next = the_node;                                          
40003c28:	fa 20 40 00 	st  %i5, [ %g1 ]                               
  the_node->previous = old_last;                                      
40003c2c:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
                                                                      
      IMFS_remove_from_directory( node );                             
      IMFS_add_to_directory( new_parent, node );                      
      IMFS_update_ctime( node );                                      
40003c30:	90 07 bf f8 	add  %fp, -8, %o0                              
40003c34:	40 00 01 9f 	call  400042b0 <gettimeofday>                  
40003c38:	92 10 20 00 	clr  %o1                                       
40003c3c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40003c40:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
  const rtems_filesystem_location_info_t *newparentloc,               
  const char *name,                                                   
  size_t namelen                                                      
)                                                                     
{                                                                     
  int rv = 0;                                                         
40003c44:	81 c7 e0 08 	ret                                            
40003c48:	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;                                           
40003c4c:	40 00 33 3d 	call  40010940 <__errno>                       <== NOT EXECUTED
40003c50:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40003c54:	82 10 20 5b 	mov  0x5b, %g1                                 <== NOT EXECUTED
40003c58:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40003c5c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003c60:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
40003c64:	40 00 33 37 	call  40010940 <__errno>                       <== NOT EXECUTED
40003c68:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40003c6c:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40003c70:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003c74:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003c78:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40003d68 <IMFS_unmount>: #endif #include "imfs.h" int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
40003d68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access; 
40003d6c:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
40003d70:	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;                  
40003d74:	c4 00 60 4c 	ld  [ %g1 + 0x4c ], %g2                        
                                                                      
  if ( IMFS_is_directory( node ) ) {                                  
40003d78:	c4 00 80 00 	ld  [ %g2 ], %g2                               
40003d7c:	80 a0 a0 00 	cmp  %g2, 0                                    
40003d80:	12 80 00 0f 	bne  40003dbc <IMFS_unmount+0x54>              <== NEVER TAKEN
40003d84:	01 00 00 00 	nop                                            
    if ( node->info.directory.mt_fs == mt_entry ) {                   
40003d88:	c4 00 60 5c 	ld  [ %g1 + 0x5c ], %g2                        
40003d8c:	80 a0 80 18 	cmp  %g2, %i0                                  
40003d90:	12 80 00 05 	bne  40003da4 <IMFS_unmount+0x3c>              <== NEVER TAKEN
40003d94:	01 00 00 00 	nop                                            
      node->info.directory.mt_fs = NULL;                              
40003d98:	c0 20 60 5c 	clr  [ %g1 + 0x5c ]                            
                                                                      
#include "imfs.h"                                                     
                                                                      
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )    
{                                                                     
  int rv = 0;                                                         
40003d9c:	81 c7 e0 08 	ret                                            
40003da0:	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;                                                 
40003da4:	40 00 32 e7 	call  40010940 <__errno>                       <== NOT EXECUTED
40003da8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40003dac:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40003db0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40003db4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003db8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = ENOTDIR;                                                  
40003dbc:	40 00 32 e1 	call  40010940 <__errno>                       <== NOT EXECUTED
40003dc0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40003dc4:	82 10 20 14 	mov  0x14, %g1                                 <== NOT EXECUTED
40003dc8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40003dcc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003dd0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400044b0 <RTEMS_Malloc_Initialize>: void RTEMS_Malloc_Initialize( const Heap_Area *areas, size_t area_count, Heap_Initialization_or_extend_handler extend ) {
400044b0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Heap_Control *heap = RTEMS_Malloc_Heap;                             
                                                                      
  if ( !rtems_configuration_get_unified_work_area() ) {               
400044b4:	03 10 00 75 	sethi  %hi(0x4001d400), %g1                    
400044b8:	c2 08 62 49 	ldub  [ %g1 + 0x249 ], %g1	! 4001d649 <Configuration+0x31>
  const Heap_Area *areas,                                             
  size_t area_count,                                                  
  Heap_Initialization_or_extend_handler extend                        
)                                                                     
{                                                                     
  Heap_Control *heap = RTEMS_Malloc_Heap;                             
400044bc:	05 10 00 7d 	sethi  %hi(0x4001f400), %g2                    
                                                                      
  if ( !rtems_configuration_get_unified_work_area() ) {               
400044c0:	80 a0 60 00 	cmp  %g1, 0                                    
400044c4:	12 80 00 17 	bne  40004520 <RTEMS_Malloc_Initialize+0x70>   
400044c8:	f6 00 a1 60 	ld  [ %g2 + 0x160 ], %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) {                                
400044cc:	80 a6 60 00 	cmp  %i1, 0                                    
400044d0:	02 80 00 23 	be  4000455c <RTEMS_Malloc_Initialize+0xac>    
400044d4:	21 10 00 26 	sethi  %hi(0x40009800), %l0                    
400044d8:	ba 10 20 00 	clr  %i5                                       
400044dc:	a0 14 20 98 	or  %l0, 0x98, %l0                             
400044e0:	b8 10 00 10 	mov  %l0, %i4                                  
      const Heap_Area *area = &areas [i];                             
      uintptr_t space_available = (*init_or_extend)(                  
400044e4:	d2 06 00 00 	ld  [ %i0 ], %o1                               
400044e8:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
400044ec:	90 10 00 1b 	mov  %i3, %o0                                  
400044f0:	9f c7 00 00 	call  %i4                                      
400044f4:	96 10 20 08 	mov  8, %o3                                    
        area->begin,                                                  
        area->size,                                                   
        page_size                                                     
      );                                                              
                                                                      
      if ( space_available > 0 ) {                                    
400044f8:	80 a2 20 00 	cmp  %o0, 0                                    
400044fc:	32 80 00 02 	bne,a   40004504 <RTEMS_Malloc_Initialize+0x54><== ALWAYS TAKEN
40004500:	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) {                                
40004504:	ba 07 60 01 	inc  %i5                                       
40004508:	80 a7 40 19 	cmp  %i5, %i1                                  
4000450c:	12 bf ff f6 	bne  400044e4 <RTEMS_Malloc_Initialize+0x34>   <== NEVER TAKEN
40004510:	b0 06 20 08 	add  %i0, 8, %i0                               
      if ( space_available > 0 ) {                                    
        init_or_extend = extend;                                      
      }                                                               
    }                                                                 
                                                                      
    if ( init_or_extend == _Heap_Initialize ) {                       
40004514:	80 a7 00 10 	cmp  %i4, %l0                                  
40004518:	02 80 00 12 	be  40004560 <RTEMS_Malloc_Initialize+0xb0>    <== NEVER TAKEN
4000451c:	90 10 20 00 	clr  %o0                                       
  }                                                                   
                                                                      
  /*                                                                  
   *  If configured, initialize the statistics support                
   */                                                                 
  if ( rtems_malloc_statistics_helpers != NULL ) {                    
40004520:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
40004524:	c2 00 60 90 	ld  [ %g1 + 0x90 ], %g1	! 4001fc90 <rtems_malloc_statistics_helpers>
40004528:	80 a0 60 00 	cmp  %g1, 0                                    
4000452c:	02 80 00 05 	be  40004540 <RTEMS_Malloc_Initialize+0x90>    
40004530:	3b 10 00 80 	sethi  %hi(0x40020000), %i5                    
    (*rtems_malloc_statistics_helpers->initialize)();                 
40004534:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40004538:	9f c0 40 00 	call  %g1                                      
4000453c:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  MSBUMP( space_available, _Protected_heap_Get_size( heap ) );        
40004540:	f8 07 61 30 	ld  [ %i5 + 0x130 ], %i4                       
40004544:	40 00 17 e3 	call  4000a4d0 <_Protected_heap_Get_size>      
40004548:	90 10 00 1b 	mov  %i3, %o0                                  
4000454c:	90 02 00 1c 	add  %o0, %i4, %o0                             
40004550:	d0 27 61 30 	st  %o0, [ %i5 + 0x130 ]                       
40004554:	81 c7 e0 08 	ret                                            
40004558:	81 e8 00 00 	restore                                        
        init_or_extend = extend;                                      
      }                                                               
    }                                                                 
                                                                      
    if ( init_or_extend == _Heap_Initialize ) {                       
      _Internal_error_Occurred(                                       
4000455c:	90 10 20 00 	clr  %o0                                       
40004560:	92 10 20 01 	mov  1, %o1                                    
40004564:	40 00 15 6a 	call  40009b0c <_Internal_error_Occurred>      
40004568:	94 10 20 17 	mov  0x17, %o2                                 
                                                                      

4002621c <Stack_check_Dump_threads_usage>: static rtems_printk_plugin_t print_handler; static void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) {
4002621c:	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) {                        
40026220:	80 a6 3f ff 	cmp  %i0, -1                                   <== NOT EXECUTED
40026224:	02 80 00 56 	be  4002637c <Stack_check_Dump_threads_usage+0x160><== NOT EXECUTED
40026228:	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 );
4002622c:	e2 06 21 38 	ld  [ %i0 + 0x138 ], %l1                       <== NOT EXECUTED
40026230:	f8 06 20 b8 	ld  [ %i0 + 0xb8 ], %i4                        <== NOT EXECUTED
    }                                                                 
                                                                      
  low  = Stack_check_usable_stack_start(stack);                       
  size = Stack_check_usable_stack_size(stack);                        
40026234:	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;                                       
40026238:	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);                        
4002623c:	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++)                 
40026240:	86 0e bf fc 	and  %i2, -4, %g3                              <== NOT EXECUTED
40026244:	86 00 40 03 	add  %g1, %g3, %g3                             <== NOT EXECUTED
40026248:	80 a0 40 03 	cmp  %g1, %g3                                  <== NOT EXECUTED
4002624c:	1a 80 00 10 	bcc  4002628c <Stack_check_Dump_threads_usage+0x70><== NOT EXECUTED
40026250:	05 29 69 69 	sethi  %hi(0xa5a5a400), %g2                    <== NOT EXECUTED
      if (*base != U32_PATTERN)                                       
40026254:	c8 07 20 20 	ld  [ %i4 + 0x20 ], %g4                        <== NOT EXECUTED
40026258:	84 10 a1 a5 	or  %g2, 0x1a5, %g2                            <== NOT EXECUTED
4002625c:	80 a1 00 02 	cmp  %g4, %g2                                  <== NOT EXECUTED
40026260:	22 80 00 08 	be,a   40026280 <Stack_check_Dump_threads_usage+0x64><== NOT EXECUTED
40026264:	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);                       
40026268:	10 80 00 37 	b  40026344 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
4002626c:	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)                                       
40026270:	80 a0 80 04 	cmp  %g2, %g4                                  <== NOT EXECUTED
40026274:	12 80 00 34 	bne  40026344 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
40026278:	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++)                 
4002627c:	82 00 60 04 	add  %g1, 4, %g1                               <== NOT EXECUTED
40026280:	80 a0 c0 01 	cmp  %g3, %g1                                  <== NOT EXECUTED
40026284:	38 bf ff fb 	bgu,a   40026270 <Stack_check_Dump_threads_usage+0x54><== NOT EXECUTED
40026288:	c4 00 40 00 	ld  [ %g1 ], %g2                               <== NOT EXECUTED
  else                                                                
    used = 0;                                                         
                                                                      
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if ( the_thread )                                                 
4002628c:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
40026290:	02 80 00 31 	be  40026354 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
40026294:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
  #endif                                                              
    {                                                                 
      (*print_handler)(                                               
40026298:	f2 06 20 08 	ld  [ %i0 + 8 ], %i1                           <== NOT EXECUTED
4002629c:	39 10 01 a3 	sethi  %hi(0x40068c00), %i4                    <== NOT EXECUTED
400262a0:	37 10 01 a3 	sethi  %hi(0x40068c00), %i3                    <== NOT EXECUTED
400262a4:	e4 07 23 84 	ld  [ %i4 + 0x384 ], %l2                       <== NOT EXECUTED
400262a8:	f0 06 e3 88 	ld  [ %i3 + 0x388 ], %i0                       <== NOT EXECUTED
400262ac:	94 07 bf f8 	add  %fp, -8, %o2                              <== NOT EXECUTED
400262b0:	92 10 20 05 	mov  5, %o1                                    <== NOT EXECUTED
400262b4:	7f ff a8 86 	call  400104cc <rtems_object_get_name>         <== NOT EXECUTED
400262b8:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
400262bc:	13 10 01 7f 	sethi  %hi(0x4005fc00), %o1                    <== NOT EXECUTED
400262c0:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
400262c4:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
400262c8:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
400262cc:	9f c6 00 00 	call  %i0                                      <== NOT EXECUTED
400262d0:	92 12 60 e8 	or  %o1, 0xe8, %o1                             <== NOT EXECUTED
                                                                      
  (*print_handler)(                                                   
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
400262d4:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           <== NOT EXECUTED
400262d8:	d6 07 40 00 	ld  [ %i5 ], %o3                               <== NOT EXECUTED
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
      }                                                               
    #endif                                                            
                                                                      
  (*print_handler)(                                                   
400262dc:	c4 06 e3 88 	ld  [ %i3 + 0x388 ], %g2                       <== NOT EXECUTED
400262e0:	d0 07 23 84 	ld  [ %i4 + 0x384 ], %o0                       <== NOT EXECUTED
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
400262e4:	96 02 ff ff 	add  %o3, -1, %o3                              <== NOT EXECUTED
      else {                                                          
        (*print_handler)( print_context, "0x%08" PRIx32 "  INTR", ~0 );
      }                                                               
    #endif                                                            
                                                                      
  (*print_handler)(                                                   
400262e8:	13 10 01 7f 	sethi  %hi(0x4005fc00), %o1                    <== NOT EXECUTED
400262ec:	96 02 80 0b 	add  %o2, %o3, %o3                             <== NOT EXECUTED
400262f0:	92 12 61 08 	or  %o1, 0x108, %o1                            <== NOT EXECUTED
400262f4:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
400262f8:	9f c0 80 00 	call  %g2                                      <== NOT EXECUTED
400262fc:	9a 10 00 1a 	mov  %i2, %o5                                  <== NOT EXECUTED
    stack->area + stack->size - 1,                                    
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
40026300:	05 10 01 a3 	sethi  %hi(0x40068c00), %g2                    <== NOT EXECUTED
40026304:	c4 00 a3 80 	ld  [ %g2 + 0x380 ], %g2	! 40068f80 <Stack_check_Initialized><== NOT EXECUTED
    (*print_handler)( print_context, "Unavailable\n" );               
40026308:	c2 06 e3 88 	ld  [ %i3 + 0x388 ], %g1                       <== NOT EXECUTED
    stack->area + stack->size - 1,                                    
    current,                                                          
    size                                                              
  );                                                                  
                                                                      
  if (Stack_check_Initialized == 0) {                                 
4002630c:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40026310:	12 80 00 07 	bne  4002632c <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
40026314:	d0 07 23 84 	ld  [ %i4 + 0x384 ], %o0                       <== NOT EXECUTED
    (*print_handler)( print_context, "Unavailable\n" );               
40026318:	13 10 01 7f 	sethi  %hi(0x4005fc00), %o1                    <== NOT EXECUTED
4002631c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40026320:	92 12 61 28 	or  %o1, 0x128, %o1	! 4005fd28 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
40026324:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40026328:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  } else {                                                            
    (*print_handler)( print_context, "%8" PRId32 "\n", used );        
4002632c:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
40026330:	13 10 01 7f 	sethi  %hi(0x4005fc00), %o1                    <== NOT EXECUTED
40026334:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40026338:	92 12 61 38 	or  %o1, 0x138, %o1	! 4005fd38 <RTEMS_BDPART_MBR_MASTER_TYPE+0x310><== NOT EXECUTED
4002633c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40026340:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  else                                                                
    used = 0;                                                         
                                                                      
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if ( the_thread )                                                 
40026344:	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 );  
40026348:	a0 04 00 1a 	add  %l0, %i2, %l0                             <== NOT EXECUTED
  else                                                                
    used = 0;                                                         
                                                                      
                                                                      
  #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)                          
    if ( the_thread )                                                 
4002634c:	12 bf ff d3 	bne  40026298 <Stack_check_Dump_threads_usage+0x7c><== NOT EXECUTED
40026350:	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 );
40026354:	37 10 01 a3 	sethi  %hi(0x40068c00), %i3                    <== NOT EXECUTED
40026358:	39 10 01 a3 	sethi  %hi(0x40068c00), %i4                    <== NOT EXECUTED
4002635c:	c2 06 e3 88 	ld  [ %i3 + 0x388 ], %g1                       <== NOT EXECUTED
40026360:	d0 07 23 84 	ld  [ %i4 + 0x384 ], %o0                       <== NOT EXECUTED
40026364:	94 10 3f ff 	mov  -1, %o2                                   <== NOT EXECUTED
40026368:	13 10 01 7f 	sethi  %hi(0x4005fc00), %o1                    <== NOT EXECUTED
4002636c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40026370:	92 12 60 f8 	or  %o1, 0xf8, %o1	! 4005fcf8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x2d0><== NOT EXECUTED
                                                                      
  (*print_handler)(                                                   
    print_context,                                                    
    " %010p - %010p %010p  %8" PRId32 "   ",                          
    stack->area,                                                      
    stack->area + stack->size - 1,                                    
40026374:	10 bf ff d9 	b  400262d8 <Stack_check_Dump_threads_usage+0xbc><== NOT EXECUTED
40026378:	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)                          
4002637c:	3b 10 01 a8 	sethi  %hi(0x4006a000), %i5                    <== NOT EXECUTED
40026380:	ba 17 62 dc 	or  %i5, 0x2dc, %i5	! 4006a2dc <Stack_check_Interrupt_stack><== NOT EXECUTED
40026384:	f8 07 60 04 	ld  [ %i5 + 4 ], %i4                           <== NOT EXECUTED
40026388:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4002638c:	02 bf ff e6 	be  40026324 <Stack_check_Dump_threads_usage+0x108><== NOT EXECUTED
40026390:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
        return;                                                       
      stack = &Stack_check_Interrupt_stack;                           
      the_thread = 0;                                                 
40026394:	10 bf ff a8 	b  40026234 <Stack_check_Dump_threads_usage+0x18><== NOT EXECUTED
40026398:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      

40026490 <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) {
40026490:	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");                                         
40026494:	11 10 01 7f 	sethi  %hi(0x4005fc00), %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);       
40026498:	fa 06 20 b8 	ld  [ %i0 + 0xb8 ], %i5                        <== NOT EXECUTED
  char           name[32];                                            
                                                                      
  printk("BLOWN STACK!!!\n");                                         
4002649c:	7f ff 79 b5 	call  40004b70 <printk>                        <== NOT EXECUTED
400264a0:	90 12 21 40 	or  %o0, 0x140, %o0                            <== NOT EXECUTED
  printk("task control block: 0x%08" PRIxPTR "\n", running);          
400264a4:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
400264a8:	11 10 01 7f 	sethi  %hi(0x4005fc00), %o0                    <== NOT EXECUTED
400264ac:	7f ff 79 b1 	call  40004b70 <printk>                        <== NOT EXECUTED
400264b0:	90 12 21 50 	or  %o0, 0x150, %o0	! 4005fd50 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328><== NOT EXECUTED
  printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);   
400264b4:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           <== NOT EXECUTED
400264b8:	11 10 01 7f 	sethi  %hi(0x4005fc00), %o0                    <== NOT EXECUTED
400264bc:	7f ff 79 ad 	call  40004b70 <printk>                        <== NOT EXECUTED
400264c0:	90 12 21 70 	or  %o0, 0x170, %o0	! 4005fd70 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348><== NOT EXECUTED
  printk(                                                             
400264c4:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1                         <== NOT EXECUTED
400264c8:	11 10 01 7f 	sethi  %hi(0x4005fc00), %o0                    <== NOT EXECUTED
400264cc:	7f ff 79 a9 	call  40004b70 <printk>                        <== NOT EXECUTED
400264d0:	90 12 21 88 	or  %o0, 0x188, %o0	! 4005fd88 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360><== NOT EXECUTED
    "task name: 0x%08" PRIx32 "\n",                                   
    running->Object.name.name_u32                                     
  );                                                                  
  printk(                                                             
400264d4:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           <== NOT EXECUTED
400264d8:	94 07 bf e0 	add  %fp, -32, %o2                             <== NOT EXECUTED
400264dc:	7f ff a7 fc 	call  400104cc <rtems_object_get_name>         <== NOT EXECUTED
400264e0:	92 10 20 20 	mov  0x20, %o1                                 <== NOT EXECUTED
400264e4:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400264e8:	11 10 01 7f 	sethi  %hi(0x4005fc00), %o0                    <== NOT EXECUTED
400264ec:	7f ff 79 a1 	call  40004b70 <printk>                        <== NOT EXECUTED
400264f0:	90 12 21 a0 	or  %o0, 0x1a0, %o0	! 4005fda0 <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)                              
400264f4:	d4 06 20 b8 	ld  [ %i0 + 0xb8 ], %o2                        <== NOT EXECUTED
400264f8:	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(                                                             
400264fc:	11 10 01 7f 	sethi  %hi(0x4005fc00), %o0                    <== NOT EXECUTED
40026500:	96 02 80 09 	add  %o2, %o1, %o3                             <== NOT EXECUTED
40026504:	7f ff 79 9b 	call  40004b70 <printk>                        <== NOT EXECUTED
40026508:	90 12 21 b8 	or  %o0, 0x1b8, %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) {                                                  
4002650c:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
40026510:	02 80 00 05 	be  40026524 <Stack_check_report_blown_task+0x94><== NOT EXECUTED
40026514:	92 10 20 10 	mov  0x10, %o1                                 <== NOT EXECUTED
          rtems_configuration_get_user_multiprocessing_table()->node  
      );                                                              
    }                                                                 
  #endif                                                              
                                                                      
  rtems_fatal(                                                        
40026518:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1                         <== NOT EXECUTED
4002651c:	7f ff 88 88 	call  4000873c <rtems_fatal>                   <== NOT EXECUTED
40026520:	90 10 20 09 	mov  9, %o0                                    <== NOT EXECUTED
    (unsigned long) stack->size,                                      
    stack->area,                                                      
    ((char *) stack->area + stack->size)                              
  );                                                                  
  if (!pattern_ok) {                                                  
    printk(                                                           
40026524:	11 10 01 7f 	sethi  %hi(0x4005fc00), %o0                    <== NOT EXECUTED
40026528:	94 07 60 08 	add  %i5, 8, %o2                               <== NOT EXECUTED
4002652c:	90 12 21 e8 	or  %o0, 0x1e8, %o0                            <== NOT EXECUTED
40026530:	7f ff 79 90 	call  40004b70 <printk>                        <== NOT EXECUTED
40026534:	96 07 60 18 	add  %i5, 0x18, %o3                            <== NOT EXECUTED
          rtems_configuration_get_user_multiprocessing_table()->node  
      );                                                              
    }                                                                 
  #endif                                                              
                                                                      
  rtems_fatal(                                                        
40026538:	10 bf ff f9 	b  4002651c <Stack_check_report_blown_task+0x8c><== NOT EXECUTED
4002653c:	d2 06 20 0c 	ld  [ %i0 + 0xc ], %o1                         <== NOT EXECUTED
                                                                      

40008f78 <_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);
40008f78:	c2 02 00 00 	ld  [ %o0 ], %g1                               
40008f7c:	80 a0 60 00 	cmp  %g1, 0                                    
40008f80:	22 80 00 04 	be,a   40008f90 <_API_extensions_Add_post_switch+0x18>
40008f84:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           
40008f88:	81 c3 e0 08 	retl                                           
40008f8c:	01 00 00 00 	nop                                            
40008f90:	80 a0 60 00 	cmp  %g1, 0                                    
40008f94:	12 bf ff fd 	bne  40008f88 <_API_extensions_Add_post_switch+0x10><== NEVER TAKEN
40008f98:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
40008f9c:	82 10 63 20 	or  %g1, 0x320, %g1	! 40020320 <_API_extensions_Post_switch_list>
40008fa0:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
                                                                      
  the_node->next = tail;                                              
40008fa4:	86 00 60 04 	add  %g1, 4, %g3                               
  tail->previous = the_node;                                          
40008fa8:	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;                                              
40008fac:	c6 22 00 00 	st  %g3, [ %o0 ]                               
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
40008fb0:	d0 20 80 00 	st  %o0, [ %g2 ]                               
  the_node->previous = old_last;                                      
40008fb4:	81 c3 e0 08 	retl                                           
40008fb8:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
                                                                      

40008fbc <_API_extensions_Run_postdriver>: } } #endif void _API_extensions_Run_postdriver( void ) {
40008fbc:	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;                              
40008fc0:	39 10 00 81 	sethi  %hi(0x40020400), %i4                    
40008fc4:	fa 07 20 68 	ld  [ %i4 + 0x68 ], %i5	! 40020468 <_API_extensions_List>
40008fc8:	b8 17 20 68 	or  %i4, 0x68, %i4                             
  Chain_Node             *the_node;                                   
  API_extensions_Control *the_extension;                              
                                                                      
  for ( the_node = _Chain_First( &_API_extensions_List );             
40008fcc:	b8 07 20 04 	add  %i4, 4, %i4                               
40008fd0:	80 a7 40 1c 	cmp  %i5, %i4                                  
40008fd4:	02 80 00 09 	be  40008ff8 <_API_extensions_Run_postdriver+0x3c><== NEVER TAKEN
40008fd8:	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)();                            
40008fdc:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40008fe0:	9f c0 40 00 	call  %g1                                      
40008fe4:	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 ) {                                 
40008fe8:	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 );             
40008fec:	80 a7 40 1c 	cmp  %i5, %i4                                  
40008ff0:	32 bf ff fc 	bne,a   40008fe0 <_API_extensions_Run_postdriver+0x24>
40008ff4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40008ff8:	81 c7 e0 08 	ret                                            
40008ffc:	81 e8 00 00 	restore                                        
                                                                      

4000b32c <_CORE_RWLock_Release>: #include <rtems/score/watchdog.h> CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) {
4000b32c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level       level;                                              
  Thread_Control *executing = _Thread_Executing;                      
4000b330:	03 10 00 70 	sethi  %hi(0x4001c000), %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 );                                              
4000b334:	7f ff e1 51 	call  40003878 <sparc_disable_interrupts>      
4000b338:	fa 00 60 f0 	ld  [ %g1 + 0xf0 ], %i5	! 4001c0f0 <_Per_CPU_Information+0x10>
4000b33c:	84 10 00 08 	mov  %o0, %g2                                  
    if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){          
4000b340:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        
4000b344:	80 a0 60 00 	cmp  %g1, 0                                    
4000b348:	02 80 00 2b 	be  4000b3f4 <_CORE_RWLock_Release+0xc8>       
4000b34c:	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 ) {
4000b350:	22 80 00 22 	be,a   4000b3d8 <_CORE_RWLock_Release+0xac>    
4000b354:	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;             
4000b358:	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;                 
4000b35c:	c0 26 20 44 	clr  [ %i0 + 0x44 ]                            
  _ISR_Enable( level );                                               
4000b360:	7f ff e1 4a 	call  40003888 <sparc_enable_interrupts>       
4000b364:	90 10 00 02 	mov  %g2, %o0                                  
                                                                      
  next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );            
4000b368:	40 00 07 e0 	call  4000d2e8 <_Thread_queue_Dequeue>         
4000b36c:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if ( next ) {                                                       
4000b370:	80 a2 20 00 	cmp  %o0, 0                                    
4000b374:	22 80 00 24 	be,a   4000b404 <_CORE_RWLock_Release+0xd8>    
4000b378:	b0 10 20 00 	clr  %i0                                       
    if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
4000b37c:	c2 02 20 30 	ld  [ %o0 + 0x30 ], %g1                        
4000b380:	80 a0 60 01 	cmp  %g1, 1                                    
4000b384:	02 80 00 22 	be  4000b40c <_CORE_RWLock_Release+0xe0>       
4000b388:	84 10 20 01 	mov  1, %g2                                    
    }                                                                 
                                                                      
    /*                                                                
     * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING                 
     */                                                               
    the_rwlock->number_of_readers += 1;                               
4000b38c:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
4000b390:	82 00 60 01 	inc  %g1                                       
    the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;       
4000b394:	c4 26 20 44 	st  %g2, [ %i0 + 0x44 ]                        
    }                                                                 
                                                                      
    /*                                                                
     * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING                 
     */                                                               
    the_rwlock->number_of_readers += 1;                               
4000b398:	10 80 00 09 	b  4000b3bc <_CORE_RWLock_Release+0x90>        
4000b39c:	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 ||                                                   
4000b3a0:	80 a0 60 01 	cmp  %g1, 1                                    
4000b3a4:	02 80 00 0b 	be  4000b3d0 <_CORE_RWLock_Release+0xa4>       <== NEVER TAKEN
4000b3a8:	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;                             
4000b3ac:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
4000b3b0:	82 00 60 01 	inc  %g1                                       
      _Thread_queue_Extract( &the_rwlock->Wait_queue, next );         
4000b3b4:	40 00 08 dd 	call  4000d728 <_Thread_queue_Extract>         
4000b3b8:	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 );          
4000b3bc:	40 00 09 2c 	call  4000d86c <_Thread_queue_First>           
4000b3c0:	90 10 00 18 	mov  %i0, %o0                                  
      if ( !next ||                                                   
4000b3c4:	92 92 20 00 	orcc  %o0, 0, %o1                              
4000b3c8:	32 bf ff f6 	bne,a   4000b3a0 <_CORE_RWLock_Release+0x74>   
4000b3cc:	c2 02 60 30 	ld  [ %o1 + 0x30 ], %g1                        
  }                                                                   
                                                                      
  /* indentation is to match _ISR_Disable at top */                   
                                                                      
  return CORE_RWLOCK_SUCCESSFUL;                                      
}                                                                     
4000b3d0:	81 c7 e0 08 	ret                                            
4000b3d4:	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;                                  
4000b3d8:	82 00 7f ff 	add  %g1, -1, %g1                              
	if ( the_rwlock->number_of_readers != 0 ) {                          
4000b3dc:	80 a0 60 00 	cmp  %g1, 0                                    
4000b3e0:	02 bf ff de 	be  4000b358 <_CORE_RWLock_Release+0x2c>       
4000b3e4:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
          /* must be unlocked again */                                
	  _ISR_Enable( level );                                              
4000b3e8:	7f ff e1 28 	call  40003888 <sparc_enable_interrupts>       
4000b3ec:	b0 10 20 00 	clr  %i0                                       
          return CORE_RWLOCK_SUCCESSFUL;                              
4000b3f0:	30 80 00 05 	b,a   4000b404 <_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 );                                           
4000b3f4:	7f ff e1 25 	call  40003888 <sparc_enable_interrupts>       
4000b3f8:	b0 10 20 00 	clr  %i0                                       
      executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;          
4000b3fc:	82 10 20 02 	mov  2, %g1                                    
4000b400:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
  }                                                                   
                                                                      
  /* indentation is to match _ISR_Disable at top */                   
                                                                      
  return CORE_RWLOCK_SUCCESSFUL;                                      
}                                                                     
4000b404:	81 c7 e0 08 	ret                                            
4000b408:	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;     
4000b40c:	82 10 20 02 	mov  2, %g1                                    
4000b410:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        
  }                                                                   
                                                                      
  /* indentation is to match _ISR_Disable at top */                   
                                                                      
  return CORE_RWLOCK_SUCCESSFUL;                                      
}                                                                     
4000b414:	81 c7 e0 08 	ret                                            
4000b418:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000b41c <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) {
4000b41c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000b420:	90 10 00 18 	mov  %i0, %o0                                  
4000b424:	40 00 06 e4 	call  4000cfb4 <_Thread_Get>                   
4000b428:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000b42c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000b430:	80 a0 60 00 	cmp  %g1, 0                                    
4000b434:	12 80 00 08 	bne  4000b454 <_CORE_RWLock_Timeout+0x38>      <== NEVER TAKEN
4000b438:	01 00 00 00 	nop                                            
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
4000b43c:	40 00 09 4d 	call  4000d970 <_Thread_queue_Process_timeout> 
4000b440:	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;                  
4000b444:	03 10 00 6e 	sethi  %hi(0x4001b800), %g1                    
4000b448:	c4 00 63 d0 	ld  [ %g1 + 0x3d0 ], %g2	! 4001bbd0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
4000b44c:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
4000b450:	c4 20 63 d0 	st  %g2, [ %g1 + 0x3d0 ]                       
4000b454:	81 c7 e0 08 	ret                                            
4000b458:	81 e8 00 00 	restore                                        
                                                                      

4000931c <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) {
4000931c:	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 )                      
40009320:	3b 10 00 80 	sethi  %hi(0x40020000), %i5                    
40009324:	c2 07 62 b0 	ld  [ %i5 + 0x2b0 ], %g1	! 400202b0 <_Thread_Dispatch_disable_level>
40009328:	80 a0 60 00 	cmp  %g1, 0                                    
4000932c:	02 80 00 1f 	be  400093a8 <_CORE_mutex_Seize+0x8c>          
40009330:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 
40009334:	80 a6 a0 00 	cmp  %i2, 0                                    
40009338:	02 80 00 2c 	be  400093e8 <_CORE_mutex_Seize+0xcc>          
4000933c:	90 10 00 18 	mov  %i0, %o0                                  
40009340:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
40009344:	c2 00 63 b8 	ld  [ %g1 + 0x3b8 ], %g1	! 400207b8 <_System_state_Current>
40009348:	80 a0 60 01 	cmp  %g1, 1                                    
4000934c:	38 80 00 2e 	bgu,a   40009404 <_CORE_mutex_Seize+0xe8>      
40009350:	90 10 20 00 	clr  %o0                                       
40009354:	40 00 14 9a 	call  4000e5bc <_CORE_mutex_Seize_interrupt_trylock>
40009358:	92 07 a0 54 	add  %fp, 0x54, %o1                            
4000935c:	80 a2 20 00 	cmp  %o0, 0                                    
40009360:	02 80 00 27 	be  400093fc <_CORE_mutex_Seize+0xe0>          <== ALWAYS TAKEN
40009364:	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;                  
40009368:	c4 07 62 b0 	ld  [ %i5 + 0x2b0 ], %g2                       
4000936c:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
40009370:	c2 00 63 d0 	ld  [ %g1 + 0x3d0 ], %g1	! 400207d0 <_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;
40009374:	86 10 20 01 	mov  1, %g3                                    
40009378:	c6 26 20 30 	st  %g3, [ %i0 + 0x30 ]                        
4000937c:	f0 20 60 44 	st  %i0, [ %g1 + 0x44 ]                        
40009380:	f2 20 60 20 	st  %i1, [ %g1 + 0x20 ]                        
                                                                      
    ++level;                                                          
40009384:	82 00 a0 01 	add  %g2, 1, %g1                               
    _Thread_Dispatch_disable_level = level;                           
40009388:	c2 27 62 b0 	st  %g1, [ %i5 + 0x2b0 ]                       
4000938c:	7f ff e4 55 	call  400024e0 <sparc_enable_interrupts>       
40009390:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
40009394:	90 10 00 18 	mov  %i0, %o0                                  
40009398:	7f ff ff ba 	call  40009280 <_CORE_mutex_Seize_interrupt_blocking>
4000939c:	92 10 00 1b 	mov  %i3, %o1                                  
400093a0:	81 c7 e0 08 	ret                                            
400093a4:	81 e8 00 00 	restore                                        
400093a8:	90 10 00 18 	mov  %i0, %o0                                  
400093ac:	40 00 14 84 	call  4000e5bc <_CORE_mutex_Seize_interrupt_trylock>
400093b0:	92 07 a0 54 	add  %fp, 0x54, %o1                            
400093b4:	80 a2 20 00 	cmp  %o0, 0                                    
400093b8:	02 bf ff fa 	be  400093a0 <_CORE_mutex_Seize+0x84>          
400093bc:	80 a6 a0 00 	cmp  %i2, 0                                    
400093c0:	12 bf ff ea 	bne  40009368 <_CORE_mutex_Seize+0x4c>         
400093c4:	01 00 00 00 	nop                                            
400093c8:	7f ff e4 46 	call  400024e0 <sparc_enable_interrupts>       
400093cc:	d0 07 a0 54 	ld  [ %fp + 0x54 ], %o0                        
400093d0:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
400093d4:	c2 00 63 d0 	ld  [ %g1 + 0x3d0 ], %g1	! 400207d0 <_Per_CPU_Information+0x10>
400093d8:	84 10 20 01 	mov  1, %g2                                    
400093dc:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
400093e0:	81 c7 e0 08 	ret                                            
400093e4:	81 e8 00 00 	restore                                        
400093e8:	40 00 14 75 	call  4000e5bc <_CORE_mutex_Seize_interrupt_trylock>
400093ec:	92 07 a0 54 	add  %fp, 0x54, %o1                            
400093f0:	80 a2 20 00 	cmp  %o0, 0                                    
400093f4:	12 bf ff f5 	bne  400093c8 <_CORE_mutex_Seize+0xac>         <== NEVER TAKEN
400093f8:	01 00 00 00 	nop                                            
400093fc:	81 c7 e0 08 	ret                                            
40009400:	81 e8 00 00 	restore                                        
40009404:	92 10 20 00 	clr  %o1                                       
40009408:	40 00 01 c1 	call  40009b0c <_Internal_error_Occurred>      
4000940c:	94 10 20 12 	mov  0x12, %o2                                 
                                                                      

4000958c <_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 ) {
4000958c:	9d e3 bf a0 	save  %sp, -96, %sp                            
40009590:	ba 10 00 18 	mov  %i0, %i5                                  
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
40009594:	b0 10 20 00 	clr  %i0                                       
                                                                      
  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
40009598:	40 00 07 a5 	call  4000b42c <_Thread_queue_Dequeue>         
4000959c:	90 10 00 1d 	mov  %i5, %o0                                  
400095a0:	80 a2 20 00 	cmp  %o0, 0                                    
400095a4:	02 80 00 04 	be  400095b4 <_CORE_semaphore_Surrender+0x28>  
400095a8:	01 00 00 00 	nop                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
400095ac:	81 c7 e0 08 	ret                                            
400095b0:	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 );                                            
400095b4:	7f ff e3 c7 	call  400024d0 <sparc_disable_interrupts>      
400095b8:	01 00 00 00 	nop                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
400095bc:	c2 07 60 48 	ld  [ %i5 + 0x48 ], %g1                        
400095c0:	c4 07 60 40 	ld  [ %i5 + 0x40 ], %g2                        
400095c4:	80 a0 40 02 	cmp  %g1, %g2                                  
400095c8:	1a 80 00 05 	bcc  400095dc <_CORE_semaphore_Surrender+0x50> <== NEVER TAKEN
400095cc:	b0 10 20 04 	mov  4, %i0                                    
        the_semaphore->count += 1;                                    
400095d0:	82 00 60 01 	inc  %g1                                       
{                                                                     
  Thread_Control *the_thread;                                         
  ISR_Level       level;                                              
  CORE_semaphore_Status status;                                       
                                                                      
  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;                          
400095d4:	b0 10 20 00 	clr  %i0                                       
#endif                                                                
                                                                      
  } else {                                                            
    _ISR_Disable( level );                                            
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
        the_semaphore->count += 1;                                    
400095d8:	c2 27 60 48 	st  %g1, [ %i5 + 0x48 ]                        
      else                                                            
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;               
    _ISR_Enable( level );                                             
400095dc:	7f ff e3 c1 	call  400024e0 <sparc_enable_interrupts>       
400095e0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
400095e4:	81 c7 e0 08 	ret                                            
400095e8:	81 e8 00 00 	restore                                        
                                                                      

4000914c <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) {
4000914c:	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;                                              
40009150:	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 );                        
40009154:	ba 06 20 04 	add  %i0, 4, %i5                               
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
40009158:	80 a6 a0 00 	cmp  %i2, 0                                    
4000915c:	02 80 00 13 	be  400091a8 <_Chain_Initialize+0x5c>          <== NEVER TAKEN
40009160:	92 06 bf ff 	add  %i2, -1, %o1                              
40009164:	86 10 00 09 	mov  %o1, %g3                                  
40009168:	82 10 00 19 	mov  %i1, %g1                                  
4000916c:	84 10 00 18 	mov  %i0, %g2                                  
    current->next  = next;                                            
40009170:	c2 20 80 00 	st  %g1, [ %g2 ]                               
    next->previous = current;                                         
40009174:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  Chain_Node *current = head;                                         
  Chain_Node *next = starting_address;                                
                                                                      
  head->previous = NULL;                                              
                                                                      
  while ( count-- ) {                                                 
40009178:	86 00 ff ff 	add  %g3, -1, %g3                              
4000917c:	84 10 00 01 	mov  %g1, %g2                                  
40009180:	80 a0 ff ff 	cmp  %g3, -1                                   
40009184:	12 bf ff fb 	bne  40009170 <_Chain_Initialize+0x24>         
40009188:	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(                                               
4000918c:	40 00 42 00 	call  4001998c <.umul>                         
40009190:	90 10 00 1b 	mov  %i3, %o0                                  
40009194:	90 06 40 08 	add  %i1, %o0, %o0                             
    current        = next;                                            
    next           = (Chain_Node *)                                   
                        _Addresses_Add_offset( (void *) next, node_size );
  }                                                                   
                                                                      
  current->next = tail;                                               
40009198:	fa 22 00 00 	st  %i5, [ %o0 ]                               
  tail->previous = current;                                           
4000919c:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
400091a0:	81 c7 e0 08 	ret                                            
400091a4:	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;                                         
400091a8:	10 bf ff fc 	b  40009198 <_Chain_Initialize+0x4c>           <== NOT EXECUTED
400091ac:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                                                                      

400080f8 <_Event_Surrender>: rtems_event_set event_in, Event_Control *event, Thread_blocking_operation_States *sync_state, States_Control wait_state ) {
400080f8:	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 );                                              
400080fc:	7f ff e8 f5 	call  400024d0 <sparc_disable_interrupts>      
40008100:	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;                                   
40008104:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40008108:	b2 16 40 01 	or  %i1, %g1, %i1                              
4000810c:	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;                           
40008110:	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 ) ) {                      
40008114:	84 8e 40 01 	andcc  %i1, %g1, %g2                           
40008118:	02 80 00 35 	be  400081ec <_Event_Surrender+0xf4>           
4000811c:	07 10 00 81 	sethi  %hi(0x40020400), %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() &&                                       
40008120:	86 10 e3 c0 	or  %g3, 0x3c0, %g3	! 400207c0 <_Per_CPU_Information>
40008124:	c8 00 e0 08 	ld  [ %g3 + 8 ], %g4                           
40008128:	80 a1 20 00 	cmp  %g4, 0                                    
4000812c:	32 80 00 1c 	bne,a   4000819c <_Event_Surrender+0xa4>       
40008130:	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);                     
40008134:	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 ) ) {   
40008138:	80 8f 00 03 	btst  %i4, %g3                                 
4000813c:	02 80 00 2c 	be  400081ec <_Event_Surrender+0xf4>           
40008140:	80 a0 40 02 	cmp  %g1, %g2                                  
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
40008144:	02 80 00 04 	be  40008154 <_Event_Surrender+0x5c>           
40008148:	80 8f 60 02 	btst  2, %i5                                   
4000814c:	02 80 00 28 	be  400081ec <_Event_Surrender+0xf4>           <== NEVER TAKEN
40008150:	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;
40008154:	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) );                            
40008158:	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(                      
4000815c:	f2 26 80 00 	st  %i1, [ %i2 ]                               
        pending_events,                                               
        seized_events                                                 
      );                                                              
      the_thread->Wait.count = 0;                                     
40008160:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40008164:	c4 20 40 00 	st  %g2, [ %g1 ]                               
                                                                      
      _ISR_Flash( level );                                            
40008168:	7f ff e8 de 	call  400024e0 <sparc_enable_interrupts>       
4000816c:	01 00 00 00 	nop                                            
40008170:	7f ff e8 d8 	call  400024d0 <sparc_disable_interrupts>      
40008174:	01 00 00 00 	nop                                            
                                                                      
      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {             
40008178:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        
4000817c:	80 a0 60 02 	cmp  %g1, 2                                    
40008180:	02 80 00 1d 	be  400081f4 <_Event_Surrender+0xfc>           
40008184:	82 10 20 03 	mov  3, %g1                                    
        _ISR_Enable( level );                                         
40008188:	7f ff e8 d6 	call  400024e0 <sparc_enable_interrupts>       
4000818c:	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 );                  
40008190:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1007fff8 <RAM_SIZE+0xfc7fff8>
40008194:	40 00 0a e0 	call  4000ad14 <_Thread_Clear_state>           
40008198:	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() &&                                       
4000819c:	80 a6 00 03 	cmp  %i0, %g3                                  
400081a0:	32 bf ff e6 	bne,a   40008138 <_Event_Surrender+0x40>       
400081a4:	c6 06 20 10 	ld  [ %i0 + 0x10 ], %g3                        
       _Thread_Is_executing( the_thread ) &&                          
       ((*sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||         
400081a8:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
400081ac:	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 ) &&                          
400081b0:	80 a0 e0 01 	cmp  %g3, 1                                    
400081b4:	38 bf ff e1 	bgu,a   40008138 <_Event_Surrender+0x40>       
400081b8:	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) ) {
400081bc:	80 a0 40 02 	cmp  %g1, %g2                                  
400081c0:	02 80 00 04 	be  400081d0 <_Event_Surrender+0xd8>           
400081c4:	80 8f 60 02 	btst  2, %i5                                   
400081c8:	02 80 00 09 	be  400081ec <_Event_Surrender+0xf4>           <== NEVER TAKEN
400081cc:	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;
400081d0:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
400081d4:	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(                      
400081d8:	f2 26 80 00 	st  %i1, [ %i2 ]                               
        pending_events,                                               
        seized_events                                                 
      );                                                              
      the_thread->Wait.count = 0;                                     
400081dc:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
400081e0:	c4 20 40 00 	st  %g2, [ %g1 ]                               
      *sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;              
400081e4:	82 10 20 03 	mov  3, %g1                                    
400081e8:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
        _Thread_Unblock( the_thread );                                
      }                                                               
      return;                                                         
    }                                                                 
  }                                                                   
  _ISR_Enable( level );                                               
400081ec:	7f ff e8 bd 	call  400024e0 <sparc_enable_interrupts>       
400081f0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(                       
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  the_watchdog->state = WATCHDOG_REMOVE_IT;                           
400081f4:	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 );                                         
400081f8:	7f ff e8 ba 	call  400024e0 <sparc_enable_interrupts>       
400081fc:	33 04 01 ff 	sethi  %hi(0x1007fc00), %i1                    
        (void) _Watchdog_Remove( &the_thread->Timer );                
40008200:	40 00 0f 4d 	call  4000bf34 <_Watchdog_Remove>              
40008204:	90 06 20 48 	add  %i0, 0x48, %o0                            
40008208:	b2 16 63 f8 	or  %i1, 0x3f8, %i1                            
4000820c:	40 00 0a c2 	call  4000ad14 <_Thread_Clear_state>           
40008210:	81 e8 00 00 	restore                                        
                                                                      

40008214 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *arg ) {
40008214:	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 );                          
40008218:	90 10 00 18 	mov  %i0, %o0                                  
4000821c:	40 00 0b b7 	call  4000b0f8 <_Thread_Get>                   
40008220:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40008224:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008228:	80 a0 60 00 	cmp  %g1, 0                                    
4000822c:	12 80 00 15 	bne  40008280 <_Event_Timeout+0x6c>            <== NEVER TAKEN
40008230:	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 );                                          
40008234:	7f ff e8 a7 	call  400024d0 <sparc_disable_interrupts>      
40008238:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (                      
  const Thread_Control *the_thread                                    
)                                                                     
{                                                                     
  return ( the_thread == _Thread_Executing );                         
4000823c:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
            return;                                                   
          }                                                           
        #endif                                                        
                                                                      
        the_thread->Wait.count = 0;                                   
        if ( _Thread_Is_executing( the_thread ) ) {                   
40008240:	c2 00 63 d0 	ld  [ %g1 + 0x3d0 ], %g1	! 400207d0 <_Per_CPU_Information+0x10>
40008244:	80 a7 40 01 	cmp  %i5, %g1                                  
40008248:	02 80 00 10 	be  40008288 <_Event_Timeout+0x74>             
4000824c:	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;                 
40008250:	82 10 20 06 	mov  6, %g1                                    
40008254:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
      _ISR_Enable( level );                                           
40008258:	7f ff e8 a2 	call  400024e0 <sparc_enable_interrupts>       
4000825c:	01 00 00 00 	nop                                            
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
40008260:	90 10 00 1d 	mov  %i5, %o0                                  
40008264:	13 04 01 ff 	sethi  %hi(0x1007fc00), %o1                    
40008268:	40 00 0a ab 	call  4000ad14 <_Thread_Clear_state>           
4000826c:	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;                  
40008270:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
40008274:	c4 00 62 b0 	ld  [ %g1 + 0x2b0 ], %g2	! 400202b0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
40008278:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
4000827c:	c4 20 62 b0 	st  %g2, [ %g1 + 0x2b0 ]                       
40008280:	81 c7 e0 08 	ret                                            
40008284:	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 )
40008288:	c2 06 40 00 	ld  [ %i1 ], %g1                               
4000828c:	80 a0 60 01 	cmp  %g1, 1                                    
40008290:	12 bf ff f1 	bne  40008254 <_Event_Timeout+0x40>            
40008294:	82 10 20 06 	mov  6, %g1                                    
            *sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;          
40008298:	82 10 20 02 	mov  2, %g1                                    
4000829c:	10 bf ff ed 	b  40008250 <_Event_Timeout+0x3c>              
400082a0:	c2 26 40 00 	st  %g1, [ %i1 ]                               
                                                                      

4000e71c <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) {
4000e71c:	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
4000e720:	a2 06 60 04 	add  %i1, 4, %l1                               
  Heap_Control *heap,                                                 
  uintptr_t alloc_size,                                               
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
4000e724:	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 ) {                              
4000e728:	80 a6 40 11 	cmp  %i1, %l1                                  
4000e72c:	18 80 00 85 	bgu  4000e940 <_Heap_Allocate_aligned_with_boundary+0x224>
4000e730:	ea 06 20 10 	ld  [ %i0 + 0x10 ], %l5                        
    /* Integer overflow occured */                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if ( boundary != 0 ) {                                              
4000e734:	80 a6 e0 00 	cmp  %i3, 0                                    
4000e738:	12 80 00 7c 	bne  4000e928 <_Heap_Allocate_aligned_with_boundary+0x20c>
4000e73c:	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;                            
4000e740:	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 ) {                               
4000e744:	80 a4 00 1d 	cmp  %l0, %i5                                  
4000e748:	02 80 00 18 	be  4000e7a8 <_Heap_Allocate_aligned_with_boundary+0x8c>
4000e74c:	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;                 
4000e750:	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    
4000e754:	ae 05 60 07 	add  %l5, 7, %l7                               
    + HEAP_BLOCK_HEADER_SIZE + page_size - 1;                         
                                                                      
  uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;                 
4000e758:	ac 25 80 19 	sub  %l6, %i1, %l6                             
4000e75c:	10 80 00 0b 	b  4000e788 <_Heap_Allocate_aligned_with_boundary+0x6c>
4000e760:	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 ) {                                       
4000e764:	12 80 00 18 	bne  4000e7c4 <_Heap_Allocate_aligned_with_boundary+0xa8>
4000e768:	b0 07 60 08 	add  %i5, 8, %i0                               
      }                                                               
                                                                      
      /* Statistics */                                                
      ++search_count;                                                 
                                                                      
      if ( alloc_begin != 0 ) {                                       
4000e76c:	80 a6 20 00 	cmp  %i0, 0                                    
4000e770:	12 80 00 4d 	bne  4000e8a4 <_Heap_Allocate_aligned_with_boundary+0x188><== ALWAYS TAKEN
4000e774:	b8 07 20 01 	inc  %i4                                       
        break;                                                        
      }                                                               
                                                                      
      block = block->next;                                            
4000e778:	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 ) {                               
4000e77c:	80 a4 00 1d 	cmp  %l0, %i5                                  
4000e780:	22 80 00 0b 	be,a   4000e7ac <_Heap_Allocate_aligned_with_boundary+0x90>
4000e784:	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 ) {                
4000e788:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
4000e78c:	80 a4 40 01 	cmp  %l1, %g1                                  
4000e790:	0a bf ff f5 	bcs  4000e764 <_Heap_Allocate_aligned_with_boundary+0x48>
4000e794:	80 a6 a0 00 	cmp  %i2, 0                                    
                                                                      
      if ( alloc_begin != 0 ) {                                       
        break;                                                        
      }                                                               
                                                                      
      block = block->next;                                            
4000e798:	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 ) {                               
4000e79c:	80 a4 00 1d 	cmp  %l0, %i5                                  
4000e7a0:	12 bf ff fa 	bne  4000e788 <_Heap_Allocate_aligned_with_boundary+0x6c>
4000e7a4:	b8 07 20 01 	inc  %i4                                       
      boundary                                                        
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->max_search < search_count ) {                           
4000e7a8:	c2 04 20 44 	ld  [ %l0 + 0x44 ], %g1                        
4000e7ac:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000e7b0:	1a 80 00 03 	bcc  4000e7bc <_Heap_Allocate_aligned_with_boundary+0xa0>
4000e7b4:	b0 10 20 00 	clr  %i0                                       
    stats->max_search = search_count;                                 
4000e7b8:	f8 24 20 44 	st  %i4, [ %l0 + 0x44 ]                        
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
4000e7bc:	81 c7 e0 08 	ret                                            
4000e7c0:	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;              
4000e7c4:	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;                
4000e7c8:	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;                     
4000e7cc:	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;                         
4000e7d0:	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;               
4000e7d4:	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);                                 
4000e7d8:	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;                     
4000e7dc:	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    
4000e7e0:	a4 00 80 12 	add  %g2, %l2, %l2                             
4000e7e4:	40 00 2d 50 	call  40019d24 <.urem>                         
4000e7e8:	90 10 00 18 	mov  %i0, %o0                                  
4000e7ec:	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 ) {                          
4000e7f0:	80 a4 80 18 	cmp  %l2, %i0                                  
4000e7f4:	1a 80 00 06 	bcc  4000e80c <_Heap_Allocate_aligned_with_boundary+0xf0>
4000e7f8:	a6 07 60 08 	add  %i5, 8, %l3                               
4000e7fc:	90 10 00 12 	mov  %l2, %o0                                  
4000e800:	40 00 2d 49 	call  40019d24 <.urem>                         
4000e804:	92 10 00 1a 	mov  %i2, %o1                                  
4000e808:	b0 24 80 08 	sub  %l2, %o0, %i0                             
  }                                                                   
                                                                      
  alloc_end = alloc_begin + alloc_size;                               
                                                                      
  /* Ensure boundary constaint */                                     
  if ( boundary != 0 ) {                                              
4000e80c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000e810:	02 80 00 37 	be  4000e8ec <_Heap_Allocate_aligned_with_boundary+0x1d0>
4000e814:	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;                               
4000e818:	86 06 00 19 	add  %i0, %i1, %g3                             
4000e81c:	92 10 00 1b 	mov  %i3, %o1                                  
4000e820:	90 10 00 03 	mov  %g3, %o0                                  
4000e824:	40 00 2d 40 	call  40019d24 <.urem>                         
4000e828:	c6 27 bf f8 	st  %g3, [ %fp + -8 ]                          
4000e82c:	c6 07 bf f8 	ld  [ %fp + -8 ], %g3                          
4000e830:	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 ) {
4000e834:	80 a6 00 08 	cmp  %i0, %o0                                  
4000e838:	1a 80 00 2c 	bcc  4000e8e8 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000e83c:	a4 04 c0 19 	add  %l3, %i1, %l2                             
4000e840:	80 a2 00 03 	cmp  %o0, %g3                                  
4000e844:	2a 80 00 12 	bcs,a   4000e88c <_Heap_Allocate_aligned_with_boundary+0x170>
4000e848:	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 ) {                           
4000e84c:	10 80 00 28 	b  4000e8ec <_Heap_Allocate_aligned_with_boundary+0x1d0>
4000e850:	80 a4 c0 18 	cmp  %l3, %i0                                  
4000e854:	92 10 00 1a 	mov  %i2, %o1                                  
4000e858:	40 00 2d 33 	call  40019d24 <.urem>                         
4000e85c:	90 10 00 18 	mov  %i0, %o0                                  
4000e860:	92 10 00 1b 	mov  %i3, %o1                                  
4000e864:	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;                           
4000e868:	ac 06 00 19 	add  %i0, %i1, %l6                             
4000e86c:	40 00 2d 2e 	call  40019d24 <.urem>                         
4000e870:	90 10 00 16 	mov  %l6, %o0                                  
4000e874:	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 ) {
4000e878:	80 a2 00 16 	cmp  %o0, %l6                                  
4000e87c:	1a 80 00 1b 	bcc  4000e8e8 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000e880:	80 a6 00 08 	cmp  %i0, %o0                                  
4000e884:	1a 80 00 19 	bcc  4000e8e8 <_Heap_Allocate_aligned_with_boundary+0x1cc>
4000e888:	80 a4 80 08 	cmp  %l2, %o0                                  
      if ( boundary_line < boundary_floor ) {                         
4000e88c:	08 bf ff f2 	bleu  4000e854 <_Heap_Allocate_aligned_with_boundary+0x138>
4000e890:	b0 22 00 19 	sub  %o0, %i1, %i0                             
        return 0;                                                     
4000e894:	b0 10 20 00 	clr  %i0                                       
      }                                                               
                                                                      
      /* Statistics */                                                
      ++search_count;                                                 
                                                                      
      if ( alloc_begin != 0 ) {                                       
4000e898:	80 a6 20 00 	cmp  %i0, 0                                    
4000e89c:	02 bf ff b7 	be  4000e778 <_Heap_Allocate_aligned_with_boundary+0x5c><== ALWAYS TAKEN
4000e8a0:	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;                                                  
4000e8a4:	c6 04 20 48 	ld  [ %l0 + 0x48 ], %g3                        
    stats->searches += search_count;                                  
4000e8a8:	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;                                                  
4000e8ac:	86 00 e0 01 	inc  %g3                                       
    stats->searches += search_count;                                  
4000e8b0:	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;                                                  
4000e8b4:	c6 24 20 48 	st  %g3, [ %l0 + 0x48 ]                        
    stats->searches += search_count;                                  
4000e8b8:	c4 24 20 4c 	st  %g2, [ %l0 + 0x4c ]                        
                                                                      
    block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
4000e8bc:	90 10 00 10 	mov  %l0, %o0                                  
4000e8c0:	92 10 00 1d 	mov  %i5, %o1                                  
4000e8c4:	94 10 00 18 	mov  %i0, %o2                                  
4000e8c8:	7f ff ec 45 	call  400099dc <_Heap_Block_allocate>          
4000e8cc:	96 10 00 19 	mov  %i1, %o3                                  
      boundary                                                        
    );                                                                
  }                                                                   
                                                                      
  /* Statistics */                                                    
  if ( stats->max_search < search_count ) {                           
4000e8d0:	c2 04 20 44 	ld  [ %l0 + 0x44 ], %g1                        
4000e8d4:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000e8d8:	2a bf ff b9 	bcs,a   4000e7bc <_Heap_Allocate_aligned_with_boundary+0xa0>
4000e8dc:	f8 24 20 44 	st  %i4, [ %l0 + 0x44 ]                        
    stats->max_search = search_count;                                 
  }                                                                   
                                                                      
  return (void *) alloc_begin;                                        
}                                                                     
4000e8e0:	81 c7 e0 08 	ret                                            
4000e8e4:	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 ) {                           
4000e8e8:	80 a4 c0 18 	cmp  %l3, %i0                                  
4000e8ec:	18 bf ff ea 	bgu  4000e894 <_Heap_Allocate_aligned_with_boundary+0x178>
4000e8f0:	82 10 3f f8 	mov  -8, %g1                                   
4000e8f4:	90 10 00 18 	mov  %i0, %o0                                  
4000e8f8:	a4 20 40 1d 	sub  %g1, %i5, %l2                             
4000e8fc:	92 10 00 15 	mov  %l5, %o1                                  
4000e900:	40 00 2d 09 	call  40019d24 <.urem>                         
4000e904:	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 ) {            
4000e908:	90 a4 80 08 	subcc  %l2, %o0, %o0                           
4000e90c:	02 bf ff 99 	be  4000e770 <_Heap_Allocate_aligned_with_boundary+0x54>
4000e910:	80 a6 20 00 	cmp  %i0, 0                                    
4000e914:	80 a2 00 14 	cmp  %o0, %l4                                  
4000e918:	1a bf ff 96 	bcc  4000e770 <_Heap_Allocate_aligned_with_boundary+0x54>
4000e91c:	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;                                                     
4000e920:	10 bf ff de 	b  4000e898 <_Heap_Allocate_aligned_with_boundary+0x17c>
4000e924:	b0 10 20 00 	clr  %i0                                       
    /* Integer overflow occured */                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if ( boundary != 0 ) {                                              
    if ( boundary < alloc_size ) {                                    
4000e928:	18 80 00 06 	bgu  4000e940 <_Heap_Allocate_aligned_with_boundary+0x224>
4000e92c:	80 a6 a0 00 	cmp  %i2, 0                                    
      return NULL;                                                    
    }                                                                 
                                                                      
    if ( alignment == 0 ) {                                           
4000e930:	22 bf ff 84 	be,a   4000e740 <_Heap_Allocate_aligned_with_boundary+0x24>
4000e934:	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;                            
4000e938:	10 bf ff 83 	b  4000e744 <_Heap_Allocate_aligned_with_boundary+0x28>
4000e93c:	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;                                                      
4000e940:	81 c7 e0 08 	ret                                            
4000e944:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000e55c <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t unused __attribute__((unused)) ) {
4000e55c:	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;                              
4000e560:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  Heap_Block *extend_last_block = NULL;                               
4000e564:	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))                            
)                                                                     
{                                                                     
4000e568:	b8 10 00 18 	mov  %i0, %i4                                  
  Heap_Statistics *const stats = &heap->stats;                        
  Heap_Block *const first_block = heap->first_block;                  
4000e56c:	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;
4000e570:	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;                        
4000e574:	e4 06 20 10 	ld  [ %i0 + 0x10 ], %l2                        
  uintptr_t const min_block_size = heap->min_block_size;              
4000e578:	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 ) {                        
4000e57c:	80 a6 40 10 	cmp  %i1, %l0                                  
4000e580:	08 80 00 04 	bleu  4000e590 <_Heap_Extend+0x34>             
4000e584:	f0 06 20 30 	ld  [ %i0 + 0x30 ], %i0                        
    return 0;                                                         
4000e588:	81 c7 e0 08 	ret                                            
4000e58c:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
                                                                      
  extend_area_ok = _Heap_Get_first_and_last_block(                    
4000e590:	90 10 00 19 	mov  %i1, %o0                                  
4000e594:	92 10 00 1a 	mov  %i2, %o1                                  
4000e598:	94 10 00 12 	mov  %l2, %o2                                  
4000e59c:	98 07 bf f8 	add  %fp, -8, %o4                              
4000e5a0:	7f ff eb d6 	call  400094f8 <_Heap_Get_first_and_last_block>
4000e5a4:	9a 07 bf fc 	add  %fp, -4, %o5                              
    page_size,                                                        
    min_block_size,                                                   
    &extend_first_block,                                              
    &extend_last_block                                                
  );                                                                  
  if (!extend_area_ok ) {                                             
4000e5a8:	80 8a 20 ff 	btst  0xff, %o0                                
4000e5ac:	02 bf ff f7 	be  4000e588 <_Heap_Extend+0x2c>               
4000e5b0:	ba 10 00 11 	mov  %l1, %i5                                  
4000e5b4:	aa 10 20 00 	clr  %l5                                       
4000e5b8:	ac 10 20 00 	clr  %l6                                       
4000e5bc:	a6 10 20 00 	clr  %l3                                       
4000e5c0:	10 80 00 10 	b  4000e600 <_Heap_Extend+0xa4>                
4000e5c4:	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 ) {                    
4000e5c8:	2a 80 00 02 	bcs,a   4000e5d0 <_Heap_Extend+0x74>           
4000e5cc:	ac 10 00 1d 	mov  %i5, %l6                                  
      link_below_block = start_block;                                 
    }                                                                 
                                                                      
    if ( sub_area_end == extend_area_begin ) {                        
4000e5d0:	80 a6 c0 19 	cmp  %i3, %i1                                  
4000e5d4:	22 80 00 1e 	be,a   4000e64c <_Heap_Extend+0xf0>            
4000e5d8:	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 ) {                  
4000e5dc:	80 a6 40 1b 	cmp  %i1, %i3                                  
4000e5e0:	38 80 00 02 	bgu,a   4000e5e8 <_Heap_Extend+0x8c>           
4000e5e4:	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;                
4000e5e8:	fa 02 20 04 	ld  [ %o0 + 4 ], %i5                           
4000e5ec:	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);                 
4000e5f0:	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 );                             
4000e5f4:	80 a4 40 1d 	cmp  %l1, %i5                                  
4000e5f8:	22 80 00 1c 	be,a   4000e668 <_Heap_Extend+0x10c>           
4000e5fc:	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;                     
4000e600:	80 a7 40 11 	cmp  %i5, %l1                                  
4000e604:	22 80 00 03 	be,a   4000e610 <_Heap_Extend+0xb4>            
4000e608:	f4 07 20 18 	ld  [ %i4 + 0x18 ], %i2                        
4000e60c:	b4 10 00 1d 	mov  %i5, %i2                                  
    uintptr_t const sub_area_end = start_block->prev_size;            
4000e610:	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);                                 
4000e614:	92 10 00 12 	mov  %l2, %o1                                  
4000e618:	40 00 16 eb 	call  400141c4 <.urem>                         
4000e61c:	90 10 00 1b 	mov  %i3, %o0                                  
4000e620:	82 06 ff f8 	add  %i3, -8, %g1                              
    Heap_Block *const end_block =                                     
      _Heap_Block_of_alloc_area( sub_area_end, page_size );           
                                                                      
    if (                                                              
4000e624:	80 a6 80 10 	cmp  %i2, %l0                                  
4000e628:	0a 80 00 64 	bcs  4000e7b8 <_Heap_Extend+0x25c>             
4000e62c:	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 ) {                        
4000e630:	80 a6 80 10 	cmp  %i2, %l0                                  
4000e634:	12 bf ff e5 	bne  4000e5c8 <_Heap_Extend+0x6c>              
4000e638:	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 ) {                        
4000e63c:	80 a6 c0 19 	cmp  %i3, %i1                                  
4000e640:	12 bf ff e7 	bne  4000e5dc <_Heap_Extend+0x80>              <== ALWAYS TAKEN
4000e644:	a8 10 00 1d 	mov  %i5, %l4                                  
      start_block->prev_size = extend_area_end;                       
4000e648:	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;                
4000e64c:	fa 02 20 04 	ld  [ %o0 + 4 ], %i5                           
4000e650:	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);                 
4000e654:	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 );                             
4000e658:	80 a4 40 1d 	cmp  %l1, %i5                                  
4000e65c:	12 bf ff e9 	bne  4000e600 <_Heap_Extend+0xa4>              <== NEVER TAKEN
4000e660:	a6 10 00 08 	mov  %o0, %l3                                  
                                                                      
  if ( extend_area_begin < heap->area_begin ) {                       
4000e664:	c2 07 20 18 	ld  [ %i4 + 0x18 ], %g1                        
4000e668:	80 a6 40 01 	cmp  %i1, %g1                                  
4000e66c:	3a 80 00 4e 	bcc,a   4000e7a4 <_Heap_Extend+0x248>          
4000e670:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
    heap->area_begin = extend_area_begin;                             
4000e674:	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;   
4000e678:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000e67c:	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 ) {
4000e680:	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 =                                           
4000e684:	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;                    
4000e688:	e0 20 40 00 	st  %l0, [ %g1 ]                               
  extend_first_block->size_and_flag =                                 
    extend_first_block_size | HEAP_PREV_BLOCK_USED;                   
4000e68c:	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 =                                 
4000e690:	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;             
4000e694:	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 ) {
4000e698:	80 a1 00 01 	cmp  %g4, %g1                                  
4000e69c:	08 80 00 3c 	bleu  4000e78c <_Heap_Extend+0x230>            
4000e6a0:	c0 20 a0 04 	clr  [ %g2 + 4 ]                               
    heap->first_block = extend_first_block;                           
4000e6a4:	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 ) {                                  
4000e6a8:	80 a5 20 00 	cmp  %l4, 0                                    
4000e6ac:	02 80 00 47 	be  4000e7c8 <_Heap_Extend+0x26c>              
4000e6b0:	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;                        
4000e6b4:	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;                            
4000e6b8:	92 10 00 1d 	mov  %i5, %o1                                  
4000e6bc:	40 00 16 c2 	call  400141c4 <.urem>                         
4000e6c0:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if ( remainder != 0 ) {                                             
4000e6c4:	80 a2 20 00 	cmp  %o0, 0                                    
4000e6c8:	02 80 00 04 	be  4000e6d8 <_Heap_Extend+0x17c>              
4000e6cc:	c4 05 00 00 	ld  [ %l4 ], %g2                               
    return value - remainder + alignment;                             
4000e6d0:	b2 06 40 1d 	add  %i1, %i5, %i1                             
4000e6d4:	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 =                             
4000e6d8:	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;                
4000e6dc:	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 =                              
4000e6e0:	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;
4000e6e4:	84 10 a0 01 	or  %g2, 1, %g2                                
                                                                      
  _Heap_Free_block( heap, new_first_block );                          
4000e6e8:	90 10 00 1c 	mov  %i4, %o0                                  
4000e6ec:	92 10 00 01 	mov  %g1, %o1                                  
4000e6f0:	7f ff ff 85 	call  4000e504 <_Heap_Free_block>              
4000e6f4:	c4 26 7f fc 	st  %g2, [ %i1 + -4 ]                          
      link_below_block,                                               
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_above_block != NULL ) {                                  
4000e6f8:	80 a4 e0 00 	cmp  %l3, 0                                    
4000e6fc:	02 80 00 3a 	be  4000e7e4 <_Heap_Extend+0x288>              
4000e700:	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);                                 
4000e704:	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(             
4000e708:	a0 24 00 13 	sub  %l0, %l3, %l0                             
4000e70c:	40 00 16 ae 	call  400141c4 <.urem>                         
4000e710:	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)                 
4000e714:	c2 04 e0 04 	ld  [ %l3 + 4 ], %g1                           
4000e718:	a0 24 00 08 	sub  %l0, %o0, %l0                             
4000e71c:	82 20 40 10 	sub  %g1, %l0, %g1                             
      | HEAP_PREV_BLOCK_USED;                                         
4000e720:	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 =                                     
4000e724:	84 04 00 13 	add  %l0, %l3, %g2                             
4000e728:	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;       
4000e72c:	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 );                               
4000e730:	90 10 00 1c 	mov  %i4, %o0                                  
4000e734:	82 08 60 01 	and  %g1, 1, %g1                               
4000e738:	92 10 00 13 	mov  %l3, %o1                                  
                                                                      
  block->size_and_flag = size | flag;                                 
4000e73c:	a0 14 00 01 	or  %l0, %g1, %l0                              
4000e740:	7f ff ff 71 	call  4000e504 <_Heap_Free_block>              
4000e744:	e0 24 e0 04 	st  %l0, [ %l3 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
4000e748:	80 a4 e0 00 	cmp  %l3, 0                                    
4000e74c:	02 80 00 33 	be  4000e818 <_Heap_Extend+0x2bc>              
4000e750:	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      
4000e754:	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(                                               
4000e758:	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;       
4000e75c:	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;                                       
4000e760:	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;                       
4000e764:	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(                                               
4000e768:	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;       
4000e76c:	88 09 20 01 	and  %g4, 1, %g4                               
                                                                      
  block->size_and_flag = size | flag;                                 
4000e770:	88 17 40 04 	or  %i5, %g4, %g4                              
4000e774:	c8 20 60 04 	st  %g4, [ %g1 + 4 ]                           
4000e778:	b0 20 c0 18 	sub  %g3, %i0, %i0                             
                                                                      
  /* Statistics */                                                    
  stats->size += extended_size;                                       
4000e77c:	82 00 80 18 	add  %g2, %i0, %g1                             
4000e780:	c2 27 20 2c 	st  %g1, [ %i4 + 0x2c ]                        
                                                                      
  return extended_size;                                               
}                                                                     
4000e784:	81 c7 e0 08 	ret                                            
4000e788:	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 ) {
4000e78c:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
4000e790:	80 a0 40 02 	cmp  %g1, %g2                                  
4000e794:	2a bf ff c5 	bcs,a   4000e6a8 <_Heap_Extend+0x14c>          
4000e798:	c4 27 20 24 	st  %g2, [ %i4 + 0x24 ]                        
    heap->last_block = extend_last_block;                             
  }                                                                   
                                                                      
  if ( merge_below_block != NULL ) {                                  
4000e79c:	10 bf ff c4 	b  4000e6ac <_Heap_Extend+0x150>               
4000e7a0:	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 ) {                    
4000e7a4:	80 a4 00 01 	cmp  %l0, %g1                                  
4000e7a8:	38 bf ff b4 	bgu,a   4000e678 <_Heap_Extend+0x11c>          
4000e7ac:	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;   
4000e7b0:	10 bf ff b3 	b  4000e67c <_Heap_Extend+0x120>               
4000e7b4:	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 (                                                              
4000e7b8:	80 a6 40 1b 	cmp  %i1, %i3                                  
4000e7bc:	1a bf ff 9e 	bcc  4000e634 <_Heap_Extend+0xd8>              
4000e7c0:	80 a6 80 10 	cmp  %i2, %l0                                  
4000e7c4:	30 bf ff 71 	b,a   4000e588 <_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 ) {                            
4000e7c8:	80 a5 a0 00 	cmp  %l6, 0                                    
4000e7cc:	02 bf ff cc 	be  4000e6fc <_Heap_Extend+0x1a0>              
4000e7d0:	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;           
4000e7d4:	ac 25 80 02 	sub  %l6, %g2, %l6                             
4000e7d8:	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 =                                         
4000e7dc:	10 bf ff c8 	b  4000e6fc <_Heap_Extend+0x1a0>               
4000e7e0:	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 ) {                            
4000e7e4:	80 a5 60 00 	cmp  %l5, 0                                    
4000e7e8:	02 bf ff d8 	be  4000e748 <_Heap_Extend+0x1ec>              
4000e7ec:	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;       
4000e7f0:	c6 05 60 04 	ld  [ %l5 + 4 ], %g3                           
    _Heap_Link_above(                                                 
4000e7f4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000e7f8:	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 );       
4000e7fc:	84 20 80 15 	sub  %g2, %l5, %g2                             
                                                                      
  block->size_and_flag = size | flag;                                 
4000e800:	84 10 80 03 	or  %g2, %g3, %g2                              
4000e804:	c4 25 60 04 	st  %g2, [ %l5 + 4 ]                           
                                                                      
  last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;                  
4000e808:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000e80c:	84 10 a0 01 	or  %g2, 1, %g2                                
4000e810:	10 bf ff ce 	b  4000e748 <_Heap_Extend+0x1ec>               
4000e814:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
      extend_first_block,                                             
      extend_last_block                                               
    );                                                                
  }                                                                   
                                                                      
  if ( merge_below_block == NULL && merge_above_block == NULL ) {     
4000e818:	32 bf ff d0 	bne,a   4000e758 <_Heap_Extend+0x1fc>          
4000e81c:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
    _Heap_Free_block( heap, extend_first_block );                     
4000e820:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
4000e824:	7f ff ff 38 	call  4000e504 <_Heap_Free_block>              
4000e828:	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      
4000e82c:	10 bf ff cb 	b  4000e758 <_Heap_Extend+0x1fc>               
4000e830:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
                                                                      

4000e948 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) {
4000e948:	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 ) {                                    
4000e94c:	80 a6 60 00 	cmp  %i1, 0                                    
4000e950:	02 80 00 3c 	be  4000ea40 <_Heap_Free+0xf8>                 
4000e954:	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);                                 
4000e958:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
4000e95c:	40 00 2c f2 	call  40019d24 <.urem>                         
4000e960:	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           
4000e964:	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);                                 
4000e968:	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);                                        
4000e96c:	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;             
4000e970:	80 a2 00 02 	cmp  %o0, %g2                                  
4000e974:	0a 80 00 30 	bcs  4000ea34 <_Heap_Free+0xec>                
4000e978:	82 10 20 00 	clr  %g1                                       
4000e97c:	c8 06 20 24 	ld  [ %i0 + 0x24 ], %g4                        
4000e980:	80 a2 00 04 	cmp  %o0, %g4                                  
4000e984:	38 80 00 2d 	bgu,a   4000ea38 <_Heap_Free+0xf0>             <== NEVER TAKEN
4000e988:	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;                
4000e98c:	f6 02 20 04 	ld  [ %o0 + 4 ], %i3                           
4000e990:	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);                 
4000e994:	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;             
4000e998:	80 a0 80 03 	cmp  %g2, %g3                                  
4000e99c:	38 80 00 27 	bgu,a   4000ea38 <_Heap_Free+0xf0>             <== NEVER TAKEN
4000e9a0:	b0 08 60 ff 	and  %g1, 0xff, %i0                            <== NOT EXECUTED
4000e9a4:	80 a1 00 03 	cmp  %g4, %g3                                  
4000e9a8:	2a 80 00 24 	bcs,a   4000ea38 <_Heap_Free+0xf0>             <== NEVER TAKEN
4000e9ac:	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;                 
4000e9b0:	f8 00 e0 04 	ld  [ %g3 + 4 ], %i4                           
    return false;                                                     
  }                                                                   
                                                                      
  _Heap_Protection_block_check( heap, next_block );                   
                                                                      
  if ( !_Heap_Is_prev_used( next_block ) ) {                          
4000e9b4:	80 8f 20 01 	btst  1, %i4                                   
4000e9b8:	02 80 00 1f 	be  4000ea34 <_Heap_Free+0xec>                 <== NEVER TAKEN
4000e9bc:	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 ));
4000e9c0:	02 80 00 23 	be  4000ea4c <_Heap_Free+0x104>                
4000e9c4:	b8 0f 3f fe 	and  %i4, -2, %i4                              
4000e9c8:	82 00 c0 1c 	add  %g3, %i4, %g1                             
4000e9cc:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000e9d0:	80 88 60 01 	btst  1, %g1                                   
4000e9d4:	12 80 00 1f 	bne  4000ea50 <_Heap_Free+0x108>               
4000e9d8:	80 8e e0 01 	btst  1, %i3                                   
                                                                      
  if ( !_Heap_Is_prev_used( block ) ) {                               
4000e9dc:	02 80 00 20 	be  4000ea5c <_Heap_Free+0x114>                
4000e9e0:	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;                                 
4000e9e4:	c4 00 e0 08 	ld  [ %g3 + 8 ], %g2                           
  Heap_Block *prev = old_block->prev;                                 
4000e9e8:	c2 00 e0 0c 	ld  [ %g3 + 0xc ], %g1                         
                                                                      
  new_block->next = next;                                             
4000e9ec:	c4 22 20 08 	st  %g2, [ %o0 + 8 ]                           
  new_block->prev = prev;                                             
4000e9f0:	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;              
4000e9f4:	b8 07 00 1d 	add  %i4, %i5, %i4                             
                                                                      
  next->prev = new_block;                                             
4000e9f8:	d0 20 a0 0c 	st  %o0, [ %g2 + 0xc ]                         
  prev->next = new_block;                                             
4000e9fc:	d0 20 60 08 	st  %o0, [ %g1 + 8 ]                           
    _Heap_Free_list_replace( next_block, block );                     
    block->size_and_flag = size | HEAP_PREV_BLOCK_USED;               
4000ea00:	84 17 20 01 	or  %i4, 1, %g2                                
    next_block  = _Heap_Block_at( block, size );                      
    next_block->prev_size = size;                                     
4000ea04:	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;               
4000ea08:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
4000ea0c:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000ea10:	c4 06 20 40 	ld  [ %i0 + 0x40 ], %g2                        
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
4000ea14:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3                        
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
4000ea18:	82 00 60 01 	inc  %g1                                       
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000ea1c:	84 00 bf ff 	add  %g2, -1, %g2                              
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
4000ea20:	ba 00 c0 1d 	add  %g3, %i5, %i5                             
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
  ++stats->frees;                                                     
4000ea24:	c2 26 20 50 	st  %g1, [ %i0 + 0x50 ]                        
      stats->max_free_blocks = stats->free_blocks;                    
    }                                                                 
  }                                                                   
                                                                      
  /* Statistics */                                                    
  --stats->used_blocks;                                               
4000ea28:	c4 26 20 40 	st  %g2, [ %i0 + 0x40 ]                        
  ++stats->frees;                                                     
  stats->free_size += block_size;                                     
4000ea2c:	fa 26 20 30 	st  %i5, [ %i0 + 0x30 ]                        
                                                                      
  return( true );                                                     
4000ea30:	82 10 20 01 	mov  1, %g1                                    
4000ea34:	b0 08 60 ff 	and  %g1, 0xff, %i0                            
4000ea38:	81 c7 e0 08 	ret                                            
4000ea3c:	81 e8 00 00 	restore                                        
4000ea40:	b0 08 60 ff 	and  %g1, 0xff, %i0                            
4000ea44:	81 c7 e0 08 	ret                                            
4000ea48:	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 ) ) {                               
4000ea4c:	80 8e e0 01 	btst  1, %i3                                   
4000ea50:	32 80 00 1e 	bne,a   4000eac8 <_Heap_Free+0x180>            
4000ea54:	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                       
4000ea58:	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;                     
4000ea5c:	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);                 
4000ea60:	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;             
4000ea64:	80 a0 80 1b 	cmp  %g2, %i3                                  
4000ea68:	18 bf ff f3 	bgu  4000ea34 <_Heap_Free+0xec>                <== NEVER TAKEN
4000ea6c:	82 10 20 00 	clr  %g1                                       
4000ea70:	80 a1 00 1b 	cmp  %g4, %i3                                  
4000ea74:	2a bf ff f1 	bcs,a   4000ea38 <_Heap_Free+0xf0>             <== NEVER TAKEN
4000ea78:	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;                 
4000ea7c:	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) ) {                        
4000ea80:	80 88 a0 01 	btst  1, %g2                                   
4000ea84:	02 bf ff ec 	be  4000ea34 <_Heap_Free+0xec>                 <== NEVER TAKEN
4000ea88:	80 8e 60 ff 	btst  0xff, %i1                                
      _HAssert( false );                                              
      return( false );                                                
    }                                                                 
                                                                      
    if ( next_is_free ) {       /* coalesce both */                   
4000ea8c:	22 80 00 21 	be,a   4000eb10 <_Heap_Free+0x1c8>             
4000ea90:	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;                                     
4000ea94:	c2 00 e0 08 	ld  [ %g3 + 8 ], %g1                           
  Heap_Block *prev = block->prev;                                     
4000ea98:	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;                                        
4000ea9c:	c6 06 20 38 	ld  [ %i0 + 0x38 ], %g3                        
                                                                      
  prev->next = next;                                                  
4000eaa0:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
  next->prev = prev;                                                  
4000eaa4:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
4000eaa8:	82 00 ff ff 	add  %g3, -1, %g1                              
4000eaac:	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;
4000eab0:	b8 07 40 1c 	add  %i5, %i4, %i4                             
4000eab4:	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;        
4000eab8:	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;                                   
4000eabc:	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;        
4000eac0:	10 bf ff d3 	b  4000ea0c <_Heap_Free+0xc4>                  
4000eac4:	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;         
4000eac8:	82 17 60 01 	or  %i5, 1, %g1                                
4000eacc:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
    next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;               
4000ead0:	c8 00 e0 04 	ld  [ %g3 + 4 ], %g4                           
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
  new_block->prev = block_before;                                     
4000ead4:	f0 22 20 0c 	st  %i0, [ %o0 + 0xc ]                         
    next_block->prev_size = block_size;                               
                                                                      
    /* Statistics */                                                  
    ++stats->free_blocks;                                             
4000ead8:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
  Heap_Block *new_block                                               
)                                                                     
{                                                                     
  Heap_Block *next = block_before->next;                              
                                                                      
  new_block->next = next;                                             
4000eadc:	c4 22 20 08 	st  %g2, [ %o0 + 8 ]                           
  new_block->prev = block_before;                                     
  block_before->next = new_block;                                     
  next->prev = new_block;                                             
4000eae0:	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;               
4000eae4:	84 09 3f fe 	and  %g4, -2, %g2                              
    next_block->prev_size = block_size;                               
4000eae8:	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;               
4000eaec:	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 ) {              
4000eaf0:	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;                                             
4000eaf4:	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;                                     
4000eaf8:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
    if ( stats->max_free_blocks < stats->free_blocks ) {              
4000eafc:	80 a0 40 02 	cmp  %g1, %g2                                  
4000eb00:	08 bf ff c3 	bleu  4000ea0c <_Heap_Free+0xc4>               
4000eb04:	c2 26 20 38 	st  %g1, [ %i0 + 0x38 ]                        
      stats->max_free_blocks = stats->free_blocks;                    
4000eb08:	10 bf ff c1 	b  4000ea0c <_Heap_Free+0xc4>                  
4000eb0c:	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;        
4000eb10:	82 16 a0 01 	or  %i2, 1, %g1                                
4000eb14:	c2 26 e0 04 	st  %g1, [ %i3 + 4 ]                           
      next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;             
4000eb18:	c2 00 e0 04 	ld  [ %g3 + 4 ], %g1                           
      next_block->prev_size = size;                                   
4000eb1c:	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;             
4000eb20:	82 08 7f fe 	and  %g1, -2, %g1                              
4000eb24:	10 bf ff ba 	b  4000ea0c <_Heap_Free+0xc4>                  
4000eb28:	c2 20 e0 04 	st  %g1, [ %g3 + 4 ]                           
                                                                      

40014614 <_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;
40014614:	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;                                                   
40014618:	c0 22 40 00 	clr  [ %o1 ]                                   
  info->largest = 0;                                                  
4001461c:	c0 22 60 04 	clr  [ %o1 + 4 ]                               
  info->total = 0;                                                    
40014620:	c0 22 60 08 	clr  [ %o1 + 8 ]                               
                                                                      
  for(the_block = _Heap_Free_list_first(the_heap);                    
40014624:	88 10 20 01 	mov  1, %g4                                    
40014628:	9a 10 20 00 	clr  %o5                                       
4001462c:	80 a2 00 01 	cmp  %o0, %g1                                  
40014630:	12 80 00 04 	bne  40014640 <_Heap_Get_free_information+0x2c><== ALWAYS TAKEN
40014634:	86 10 20 00 	clr  %g3                                       
40014638:	30 80 00 10 	b,a   40014678 <_Heap_Get_free_information+0x64><== NOT EXECUTED
4001463c:	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;                
40014640:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40014644:	98 01 20 01 	add  %g4, 1, %o4                               
40014648:	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 )                                   
4001464c:	80 a0 80 0d 	cmp  %g2, %o5                                  
40014650:	08 80 00 03 	bleu  4001465c <_Heap_Get_free_information+0x48>
40014654:	86 00 c0 02 	add  %g3, %g2, %g3                             
        info->largest = the_size;                                     
40014658:	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)                                    
4001465c:	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);                    
40014660:	80 a2 00 01 	cmp  %o0, %g1                                  
40014664:	32 bf ff f6 	bne,a   4001463c <_Heap_Get_free_information+0x28>
40014668:	da 02 60 04 	ld  [ %o1 + 4 ], %o5                           
4001466c:	c8 22 40 00 	st  %g4, [ %o1 ]                               
40014670:	81 c3 e0 08 	retl                                           
40014674:	c6 22 60 08 	st  %g3, [ %o1 + 8 ]                           
40014678:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

4000b818 <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) {
4000b818:	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) {                                 
4000b81c:	80 a6 a0 00 	cmp  %i2, 0                                    
4000b820:	02 80 00 35 	be  4000b8f4 <_Heap_Greedy_allocate+0xdc>      
4000b824:	b8 10 00 18 	mov  %i0, %i4                                  
4000b828:	ba 10 20 00 	clr  %i5                                       
4000b82c:	b6 10 20 00 	clr  %i3                                       
  #include "config.h"                                                 
#endif                                                                
                                                                      
#include <rtems/score/heap.h>                                         
                                                                      
Heap_Block *_Heap_Greedy_allocate(                                    
4000b830:	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 );    
4000b834:	d2 06 40 01 	ld  [ %i1 + %g1 ], %o1                         
4000b838:	94 10 20 00 	clr  %o2                                       
4000b83c:	96 10 20 00 	clr  %o3                                       
4000b840:	40 00 1f ca 	call  40013768 <_Heap_Allocate_aligned_with_boundary>
4000b844:	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 ) {                                             
4000b848:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000b84c:	22 80 00 09 	be,a   4000b870 <_Heap_Greedy_allocate+0x58>   <== NEVER TAKEN
4000b850:	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);                                 
4000b854:	d2 07 20 10 	ld  [ %i4 + 0x10 ], %o1                        
4000b858:	40 00 37 13 	call  400194a4 <.urem>                         
4000b85c:	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);                                        
4000b860:	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;                            
4000b864:	f6 22 20 08 	st  %i3, [ %o0 + 8 ]                           
4000b868:	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) {                                 
4000b86c:	ba 07 60 01 	inc  %i5                                       
4000b870:	80 a7 40 1a 	cmp  %i5, %i2                                  
4000b874:	12 bf ff f0 	bne  4000b834 <_Heap_Greedy_allocate+0x1c>     
4000b878:	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;                            
4000b87c:	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 ) {
4000b880:	80 a7 00 1d 	cmp  %i4, %i5                                  
4000b884:	02 80 00 17 	be  4000b8e0 <_Heap_Greedy_allocate+0xc8>      <== NEVER TAKEN
4000b888:	b0 10 20 00 	clr  %i0                                       
4000b88c:	10 80 00 03 	b  4000b898 <_Heap_Greedy_allocate+0x80>       
4000b890:	b4 10 20 00 	clr  %i2                                       
4000b894:	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;                
4000b898:	d6 07 60 04 	ld  [ %i5 + 4 ], %o3                           
    _Heap_Block_allocate(                                             
4000b89c:	92 10 00 1d 	mov  %i5, %o1                                  
4000b8a0:	96 0a ff fe 	and  %o3, -2, %o3                              
4000b8a4:	94 07 60 08 	add  %i5, 8, %o2                               
4000b8a8:	90 10 00 1c 	mov  %i4, %o0                                  
4000b8ac:	40 00 00 e0 	call  4000bc2c <_Heap_Block_allocate>          
4000b8b0:	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;                                           
4000b8b4:	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;                            
4000b8b8:	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 ) {
4000b8bc:	80 a7 00 01 	cmp  %i4, %g1                                  
4000b8c0:	12 bf ff f5 	bne  4000b894 <_Heap_Greedy_allocate+0x7c>     
4000b8c4:	b4 10 00 1d 	mov  %i5, %i2                                  
4000b8c8:	10 80 00 06 	b  4000b8e0 <_Heap_Greedy_allocate+0xc8>       
4000b8cc:	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 ) );
4000b8d0:	92 06 e0 08 	add  %i3, 8, %o1                               
4000b8d4:	90 10 00 1c 	mov  %i4, %o0                                  
4000b8d8:	40 00 20 2f 	call  40013994 <_Heap_Free>                    
4000b8dc:	b6 10 00 1a 	mov  %i2, %i3                                  
                                                                      
    current->next = blocks;                                           
    blocks = current;                                                 
  }                                                                   
                                                                      
  while ( allocated_blocks != NULL ) {                                
4000b8e0:	80 a6 e0 00 	cmp  %i3, 0                                    
4000b8e4:	32 bf ff fb 	bne,a   4000b8d0 <_Heap_Greedy_allocate+0xb8>  
4000b8e8:	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;                                                      
}                                                                     
4000b8ec:	81 c7 e0 08 	ret                                            
4000b8f0:	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;                                
4000b8f4:	10 bf ff e2 	b  4000b87c <_Heap_Greedy_allocate+0x64>       
4000b8f8:	b6 10 20 00 	clr  %i3                                       
                                                                      

4000b8fc <_Heap_Greedy_free>: void _Heap_Greedy_free( Heap_Control *heap, Heap_Block *blocks ) {
4000b8fc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  while ( blocks != NULL ) {                                          
4000b900:	80 a6 60 00 	cmp  %i1, 0                                    
4000b904:	02 80 00 09 	be  4000b928 <_Heap_Greedy_free+0x2c>          <== NEVER TAKEN
4000b908:	01 00 00 00 	nop                                            
    Heap_Block *current = blocks;                                     
                                                                      
    blocks = blocks->next;                                            
4000b90c:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
    _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
4000b910:	92 06 60 08 	add  %i1, 8, %o1                               
4000b914:	40 00 20 20 	call  40013994 <_Heap_Free>                    
4000b918:	90 10 00 18 	mov  %i0, %o0                                  
void _Heap_Greedy_free(                                               
  Heap_Control *heap,                                                 
  Heap_Block *blocks                                                  
)                                                                     
{                                                                     
  while ( blocks != NULL ) {                                          
4000b91c:	b2 97 60 00 	orcc  %i5, 0, %i1                              
4000b920:	32 bf ff fc 	bne,a   4000b910 <_Heap_Greedy_free+0x14>      
4000b924:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
4000b928:	81 c7 e0 08 	ret                                            
4000b92c:	81 e8 00 00 	restore                                        
                                                                      

400146e0 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) {
400146e0:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  Heap_Block *current = heap->first_block;                            
400146e4:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        <== NOT EXECUTED
  Heap_Block *end = heap->last_block;                                 
400146e8:	f8 06 20 24 	ld  [ %i0 + 0x24 ], %i4                        <== NOT EXECUTED
  bool stop = false;                                                  
                                                                      
  while ( !stop && current != end ) {                                 
400146ec:	80 a0 40 1c 	cmp  %g1, %i4                                  <== NOT EXECUTED
400146f0:	32 80 00 08 	bne,a   40014710 <_Heap_Iterate+0x30>          <== NOT EXECUTED
400146f4:	d2 00 60 04 	ld  [ %g1 + 4 ], %o1                           <== NOT EXECUTED
400146f8:	30 80 00 10 	b,a   40014738 <_Heap_Iterate+0x58>            <== NOT EXECUTED
400146fc:	90 1a 20 01 	xor  %o0, 1, %o0                               <== NOT EXECUTED
40014700:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40014704:	02 80 00 0d 	be  40014738 <_Heap_Iterate+0x58>              <== NOT EXECUTED
40014708:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001470c:	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 );            
40014710:	90 10 00 01 	mov  %g1, %o0                                  <== NOT EXECUTED
40014714:	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);                 
40014718:	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;                 
4001471c:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           <== NOT EXECUTED
40014720:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
40014724:	9f c6 40 00 	call  %i1                                      <== NOT EXECUTED
40014728:	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 ) {                                 
4001472c:	80 a7 00 1d 	cmp  %i4, %i5                                  <== NOT EXECUTED
40014730:	12 bf ff f3 	bne  400146fc <_Heap_Iterate+0x1c>             <== NOT EXECUTED
40014734:	82 10 00 1d 	mov  %i5, %g1                                  <== NOT EXECUTED
40014738:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001473c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001d30c <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) {
4001d30c:	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);                                 
4001d310:	d2 06 20 10 	ld  [ %i0 + 0x10 ], %o1                        
4001d314:	7f ff f2 84 	call  40019d24 <.urem>                         
4001d318:	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           
4001d31c:	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);                                 
4001d320:	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);                                        
4001d324:	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;             
4001d328:	80 a2 00 01 	cmp  %o0, %g1                                  
4001d32c:	0a 80 00 16 	bcs  4001d384 <_Heap_Size_of_alloc_area+0x78>  
4001d330:	84 10 20 00 	clr  %g2                                       
4001d334:	c6 06 20 24 	ld  [ %i0 + 0x24 ], %g3                        
4001d338:	80 a2 00 03 	cmp  %o0, %g3                                  
4001d33c:	18 80 00 13 	bgu  4001d388 <_Heap_Size_of_alloc_area+0x7c>  <== NEVER TAKEN
4001d340:	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;                
4001d344:	c8 02 20 04 	ld  [ %o0 + 4 ], %g4                           
4001d348:	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);                 
4001d34c:	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;             
4001d350:	80 a0 40 08 	cmp  %g1, %o0                                  
4001d354:	18 80 00 0d 	bgu  4001d388 <_Heap_Size_of_alloc_area+0x7c>  <== NEVER TAKEN
4001d358:	01 00 00 00 	nop                                            
4001d35c:	80 a0 c0 08 	cmp  %g3, %o0                                  
4001d360:	0a 80 00 0a 	bcs  4001d388 <_Heap_Size_of_alloc_area+0x7c>  <== NEVER TAKEN
4001d364:	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;                 
4001d368:	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 )                            
4001d36c:	80 88 60 01 	btst  1, %g1                                   
4001d370:	02 80 00 06 	be  4001d388 <_Heap_Size_of_alloc_area+0x7c>   <== NEVER TAKEN
4001d374:	90 22 00 19 	sub  %o0, %i1, %o0                             
    return false;                                                     
  }                                                                   
                                                                      
  *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
                                                                      
  return true;                                                        
4001d378:	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;
4001d37c:	90 02 20 04 	add  %o0, 4, %o0                               
4001d380:	d0 26 80 00 	st  %o0, [ %i2 ]                               
4001d384:	b0 08 a0 ff 	and  %g2, 0xff, %i0                            
4001d388:	81 c7 e0 08 	ret                                            
4001d38c:	81 e8 00 00 	restore                                        
                                                                      

4000a474 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) {
4000a474:	9d e3 bf 80 	save  %sp, -128, %sp                           
  uintptr_t const page_size = heap->page_size;                        
4000a478:	f6 06 20 10 	ld  [ %i0 + 0x10 ], %i3                        
  uintptr_t const min_block_size = heap->min_block_size;              
4000a47c:	e0 06 20 14 	ld  [ %i0 + 0x14 ], %l0                        
  Heap_Block *const first_block = heap->first_block;                  
4000a480:	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;                      
4000a484:	80 a6 a0 00 	cmp  %i2, 0                                    
4000a488:	02 80 00 0c 	be  4000a4b8 <_Heap_Walk+0x44>                 
4000a48c:	e2 06 20 24 	ld  [ %i0 + 0x24 ], %l1                        
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
4000a490:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
4000a494:	c4 00 60 c8 	ld  [ %g1 + 0xc8 ], %g2	! 4001a8c8 <_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;                      
4000a498:	07 10 00 29 	sethi  %hi(0x4000a400), %g3                    
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
4000a49c:	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() ) ) {                
4000a4a0:	80 a0 a0 03 	cmp  %g2, 3                                    
4000a4a4:	02 80 00 0c 	be  4000a4d4 <_Heap_Walk+0x60>                 <== ALWAYS TAKEN
4000a4a8:	ae 10 e0 10 	or  %g3, 0x10, %l7                             
4000a4ac:	b0 08 60 ff 	and  %g1, 0xff, %i0                            
4000a4b0:	81 c7 e0 08 	ret                                            
4000a4b4:	81 e8 00 00 	restore                                        
4000a4b8:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
4000a4bc:	c4 00 60 c8 	ld  [ %g1 + 0xc8 ], %g2	! 4001a8c8 <_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;                      
4000a4c0:	07 10 00 29 	sethi  %hi(0x4000a400), %g3                    
                                                                      
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
4000a4c4:	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() ) ) {                
4000a4c8:	80 a0 a0 03 	cmp  %g2, 3                                    
4000a4cc:	12 bf ff f8 	bne  4000a4ac <_Heap_Walk+0x38>                
4000a4d0:	ae 10 e0 08 	or  %g3, 8, %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)(                                                         
4000a4d4:	da 06 20 18 	ld  [ %i0 + 0x18 ], %o5                        
4000a4d8:	c8 06 20 1c 	ld  [ %i0 + 0x1c ], %g4                        
4000a4dc:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
4000a4e0:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4000a4e4:	90 10 00 19 	mov  %i1, %o0                                  
4000a4e8:	c8 23 a0 5c 	st  %g4, [ %sp + 0x5c ]                        
4000a4ec:	f8 23 a0 60 	st  %i4, [ %sp + 0x60 ]                        
4000a4f0:	e2 23 a0 64 	st  %l1, [ %sp + 0x64 ]                        
4000a4f4:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
4000a4f8:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
4000a4fc:	92 10 20 00 	clr  %o1                                       
4000a500:	96 10 00 1b 	mov  %i3, %o3                                  
4000a504:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a508:	98 10 00 10 	mov  %l0, %o4                                  
4000a50c:	9f c5 c0 00 	call  %l7                                      
4000a510:	94 12 a0 70 	or  %o2, 0x70, %o2                             
    heap->area_begin, heap->area_end,                                 
    first_block, last_block,                                          
    first_free_block, last_free_block                                 
  );                                                                  
                                                                      
  if ( page_size == 0 ) {                                             
4000a514:	80 a6 e0 00 	cmp  %i3, 0                                    
4000a518:	02 80 00 2a 	be  4000a5c0 <_Heap_Walk+0x14c>                
4000a51c:	80 8e e0 07 	btst  7, %i3                                   
    (*printer)( source, true, "page size is zero\n" );                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
4000a520:	12 80 00 2f 	bne  4000a5dc <_Heap_Walk+0x168>               
4000a524:	90 10 00 10 	mov  %l0, %o0                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
4000a528:	7f ff dd 92 	call  40001b70 <.urem>                         
4000a52c:	92 10 00 1b 	mov  %i3, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
4000a530:	80 a2 20 00 	cmp  %o0, 0                                    
4000a534:	12 80 00 32 	bne  4000a5fc <_Heap_Walk+0x188>               
4000a538:	90 07 20 08 	add  %i4, 8, %o0                               
4000a53c:	7f ff dd 8d 	call  40001b70 <.urem>                         
4000a540:	92 10 00 1b 	mov  %i3, %o1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
4000a544:	80 a2 20 00 	cmp  %o0, 0                                    
4000a548:	32 80 00 35 	bne,a   4000a61c <_Heap_Walk+0x1a8>            
4000a54c:	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;                 
4000a550:	ec 07 20 04 	ld  [ %i4 + 4 ], %l6                           
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
4000a554:	b4 8d a0 01 	andcc  %l6, 1, %i2                             
4000a558:	22 80 00 38 	be,a   4000a638 <_Heap_Walk+0x1c4>             
4000a55c:	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;                
4000a560:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
4000a564:	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);                 
4000a568:	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;                 
4000a56c:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
4000a570:	80 8f 60 01 	btst  1, %i5                                   
4000a574:	02 80 00 0c 	be  4000a5a4 <_Heap_Walk+0x130>                
4000a578:	80 a7 00 01 	cmp  %i4, %g1                                  
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if (                                                                
4000a57c:	02 80 00 35 	be  4000a650 <_Heap_Walk+0x1dc>                
4000a580:	90 10 00 19 	mov  %i1, %o0                                  
    _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
  ) {                                                                 
    (*printer)(                                                       
4000a584:	92 10 20 01 	mov  1, %o1                                    
4000a588:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a58c:	9f c5 c0 00 	call  %l7                                      
4000a590:	94 12 a1 e8 	or  %o2, 0x1e8, %o2	! 400179e8 <__log2table+0x2d8>
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000a594:	82 10 20 00 	clr  %g1                                       
4000a598:	b0 08 60 ff 	and  %g1, 0xff, %i0                            
4000a59c:	81 c7 e0 08 	ret                                            
4000a5a0:	81 e8 00 00 	restore                                        
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( _Heap_Is_free( last_block ) ) {                                
    (*printer)(                                                       
4000a5a4:	90 10 00 19 	mov  %i1, %o0                                  
4000a5a8:	92 10 20 01 	mov  1, %o1                                    
4000a5ac:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a5b0:	9f c5 c0 00 	call  %l7                                      
4000a5b4:	94 12 a1 d0 	or  %o2, 0x1d0, %o2	! 400179d0 <__log2table+0x2c0>
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000a5b8:	10 bf ff f8 	b  4000a598 <_Heap_Walk+0x124>                 
4000a5bc:	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" );                
4000a5c0:	90 10 00 19 	mov  %i1, %o0                                  
4000a5c4:	92 10 20 01 	mov  1, %o1                                    
4000a5c8:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a5cc:	9f c5 c0 00 	call  %l7                                      
4000a5d0:	94 12 a1 08 	or  %o2, 0x108, %o2	! 40017908 <__log2table+0x1f8>
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000a5d4:	10 bf ff f1 	b  4000a598 <_Heap_Walk+0x124>                 
4000a5d8:	82 10 20 00 	clr  %g1                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Addresses_Is_aligned( (void *) page_size ) ) {               
    (*printer)(                                                       
4000a5dc:	90 10 00 19 	mov  %i1, %o0                                  
4000a5e0:	92 10 20 01 	mov  1, %o1                                    
4000a5e4:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a5e8:	96 10 00 1b 	mov  %i3, %o3                                  
4000a5ec:	9f c5 c0 00 	call  %l7                                      
4000a5f0:	94 12 a1 20 	or  %o2, 0x120, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000a5f4:	10 bf ff e9 	b  4000a598 <_Heap_Walk+0x124>                 
4000a5f8:	82 10 20 00 	clr  %g1                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {             
    (*printer)(                                                       
4000a5fc:	90 10 00 19 	mov  %i1, %o0                                  
4000a600:	92 10 20 01 	mov  1, %o1                                    
4000a604:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a608:	96 10 00 10 	mov  %l0, %o3                                  
4000a60c:	9f c5 c0 00 	call  %l7                                      
4000a610:	94 12 a1 40 	or  %o2, 0x140, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000a614:	10 bf ff e1 	b  4000a598 <_Heap_Walk+0x124>                 
4000a618:	82 10 20 00 	clr  %g1                                       
  }                                                                   
                                                                      
  if (                                                                
    !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
  ) {                                                                 
    (*printer)(                                                       
4000a61c:	92 10 20 01 	mov  1, %o1                                    
4000a620:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a624:	96 10 00 1c 	mov  %i4, %o3                                  
4000a628:	9f c5 c0 00 	call  %l7                                      
4000a62c:	94 12 a1 68 	or  %o2, 0x168, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000a630:	10 bf ff da 	b  4000a598 <_Heap_Walk+0x124>                 
4000a634:	82 10 20 00 	clr  %g1                                       
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Is_prev_used( first_block ) ) {                         
    (*printer)(                                                       
4000a638:	92 10 20 01 	mov  1, %o1                                    
4000a63c:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a640:	9f c5 c0 00 	call  %l7                                      
4000a644:	94 12 a1 a0 	or  %o2, 0x1a0, %o2	! 400179a0 <__log2table+0x290>
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000a648:	10 bf ff d4 	b  4000a598 <_Heap_Walk+0x124>                 
4000a64c:	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;                            
4000a650:	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;                        
4000a654:	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 ) {                            
4000a658:	80 a6 00 1d 	cmp  %i0, %i5                                  
4000a65c:	02 80 00 0d 	be  4000a690 <_Heap_Walk+0x21c>                
4000a660:	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;             
4000a664:	80 a3 40 1d 	cmp  %o5, %i5                                  
4000a668:	28 80 00 bf 	bleu,a   4000a964 <_Heap_Walk+0x4f0>           <== ALWAYS TAKEN
4000a66c:	e6 06 20 24 	ld  [ %i0 + 0x24 ], %l3                        
    if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {              
      (*printer)(                                                     
4000a670:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000a674:	92 10 20 01 	mov  1, %o1                                    
4000a678:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a67c:	96 10 00 1d 	mov  %i5, %o3                                  
4000a680:	9f c5 c0 00 	call  %l7                                      
4000a684:	94 12 a2 18 	or  %o2, 0x218, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000a688:	10 bf ff c4 	b  4000a598 <_Heap_Walk+0x124>                 
4000a68c:	82 10 20 00 	clr  %g1                                       
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
4000a690:	27 10 00 5f 	sethi  %hi(0x40017c00), %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)(                                                     
4000a694:	25 10 00 5f 	sethi  %hi(0x40017c00), %l2                    
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
4000a698:	aa 10 00 1c 	mov  %i4, %l5                                  
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
4000a69c:	a6 14 e0 48 	or  %l3, 0x48, %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)(                                                     
4000a6a0:	a4 14 a0 30 	or  %l2, 0x30, %l2                             
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
    block->next,                                                      
    block->next == last_free_block ?                                  
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
4000a6a4:	29 10 00 5e 	sethi  %hi(0x40017800), %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;                
4000a6a8:	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);                 
4000a6ac:	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;             
4000a6b0:	80 a3 40 1d 	cmp  %o5, %i5                                  
4000a6b4:	28 80 00 0b 	bleu,a   4000a6e0 <_Heap_Walk+0x26c>           <== ALWAYS TAKEN
4000a6b8:	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)(                                                     
4000a6bc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000a6c0:	92 10 20 01 	mov  1, %o1                                    
4000a6c4:	96 10 00 15 	mov  %l5, %o3                                  
4000a6c8:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a6cc:	98 10 00 1d 	mov  %i5, %o4                                  
4000a6d0:	9f c5 c0 00 	call  %l7                                      
4000a6d4:	94 12 a2 c0 	or  %o2, 0x2c0, %o2                            
        "block 0x%08x: next block 0x%08x not in heap\n",              
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
4000a6d8:	10 bf ff 75 	b  4000a4ac <_Heap_Walk+0x38>                  
4000a6dc:	82 10 20 00 	clr  %g1                                       
4000a6e0:	80 a3 c0 1d 	cmp  %o7, %i5                                  
4000a6e4:	0a bf ff f7 	bcs  4000a6c0 <_Heap_Walk+0x24c>               
4000a6e8:	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;               
4000a6ec:	9e 1d 40 11 	xor  %l5, %l1, %o7                             
4000a6f0:	80 a0 00 0f 	cmp  %g0, %o7                                  
4000a6f4:	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;                                    
4000a6f8:	90 10 00 16 	mov  %l6, %o0                                  
4000a6fc:	da 27 bf fc 	st  %o5, [ %fp + -4 ]                          
4000a700:	7f ff dd 1c 	call  40001b70 <.urem>                         
4000a704:	92 10 00 1b 	mov  %i3, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
4000a708:	80 a2 20 00 	cmp  %o0, 0                                    
4000a70c:	02 80 00 18 	be  4000a76c <_Heap_Walk+0x2f8>                
4000a710:	da 07 bf fc 	ld  [ %fp + -4 ], %o5                          
4000a714:	80 8b 60 ff 	btst  0xff, %o5                                
4000a718:	12 80 00 8b 	bne  4000a944 <_Heap_Walk+0x4d0>               
4000a71c:	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;                 
4000a720:	de 07 60 04 	ld  [ %i5 + 4 ], %o7                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_prev_used( next_block ) ) {                        
4000a724:	80 8b e0 01 	btst  1, %o7                                   
4000a728:	02 80 00 2b 	be  4000a7d4 <_Heap_Walk+0x360>                
4000a72c:	80 a6 a0 00 	cmp  %i2, 0                                    
      if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
        return false;                                                 
      }                                                               
    } else if (prev_used) {                                           
4000a730:	22 80 00 21 	be,a   4000a7b4 <_Heap_Walk+0x340>             
4000a734:	da 05 40 00 	ld  [ %l5 ], %o5                               
      (*printer)(                                                     
4000a738:	90 10 00 19 	mov  %i1, %o0                                  
4000a73c:	92 10 20 00 	clr  %o1                                       
4000a740:	94 10 00 12 	mov  %l2, %o2                                  
4000a744:	96 10 00 15 	mov  %l5, %o3                                  
4000a748:	9f c5 c0 00 	call  %l7                                      
4000a74c:	98 10 00 16 	mov  %l6, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
4000a750:	80 a7 00 1d 	cmp  %i4, %i5                                  
4000a754:	02 80 00 51 	be  4000a898 <_Heap_Walk+0x424>                
4000a758:	aa 10 00 1d 	mov  %i5, %l5                                  
4000a75c:	ec 07 60 04 	ld  [ %i5 + 4 ], %l6                           
4000a760:	da 06 20 20 	ld  [ %i0 + 0x20 ], %o5                        
4000a764:	10 bf ff d1 	b  4000a6a8 <_Heap_Walk+0x234>                 
4000a768:	b4 0d a0 01 	and  %l6, 1, %i2                               
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
4000a76c:	80 a5 80 10 	cmp  %l6, %l0                                  
4000a770:	0a 80 00 69 	bcs  4000a914 <_Heap_Walk+0x4a0>               
4000a774:	80 8b 60 ff 	btst  0xff, %o5                                
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( next_block_begin <= block_begin && is_not_last_block ) {     
4000a778:	80 a5 40 1d 	cmp  %l5, %i5                                  
4000a77c:	2a bf ff ea 	bcs,a   4000a724 <_Heap_Walk+0x2b0>            
4000a780:	de 07 60 04 	ld  [ %i5 + 4 ], %o7                           
4000a784:	80 8b 60 ff 	btst  0xff, %o5                                
4000a788:	22 bf ff e7 	be,a   4000a724 <_Heap_Walk+0x2b0>             
4000a78c:	de 07 60 04 	ld  [ %i5 + 4 ], %o7                           
      (*printer)(                                                     
4000a790:	90 10 00 19 	mov  %i1, %o0                                  
4000a794:	92 10 20 01 	mov  1, %o1                                    
4000a798:	96 10 00 15 	mov  %l5, %o3                                  
4000a79c:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a7a0:	98 10 00 1d 	mov  %i5, %o4                                  
4000a7a4:	9f c5 c0 00 	call  %l7                                      
4000a7a8:	94 12 a3 50 	or  %o2, 0x350, %o2                            
        "block 0x%08x: next block 0x%08x is not a successor\n",       
        block,                                                        
        next_block                                                    
      );                                                              
                                                                      
      return false;                                                   
4000a7ac:	10 bf ff 40 	b  4000a4ac <_Heap_Walk+0x38>                  
4000a7b0:	82 10 20 00 	clr  %g1                                       
        "block 0x%08x: size %u\n",                                    
        block,                                                        
        block_size                                                    
      );                                                              
    } else {                                                          
      (*printer)(                                                     
4000a7b4:	96 10 00 15 	mov  %l5, %o3                                  
4000a7b8:	90 10 00 19 	mov  %i1, %o0                                  
4000a7bc:	92 10 20 00 	clr  %o1                                       
4000a7c0:	94 10 00 13 	mov  %l3, %o2                                  
4000a7c4:	9f c5 c0 00 	call  %l7                                      
4000a7c8:	98 10 00 16 	mov  %l6, %o4                                  
        block->prev_size                                              
      );                                                              
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
4000a7cc:	10 bf ff e2 	b  4000a754 <_Heap_Walk+0x2e0>                 
4000a7d0:	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 ?                                 
4000a7d4:	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)(                                                         
4000a7d8:	de 06 20 08 	ld  [ %i0 + 8 ], %o7                           
4000a7dc:	80 a3 c0 0d 	cmp  %o7, %o5                                  
4000a7e0:	02 80 00 3d 	be  4000a8d4 <_Heap_Walk+0x460>                
4000a7e4:	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)" : ""),         
4000a7e8:	80 a6 00 0d 	cmp  %i0, %o5                                  
4000a7ec:	02 80 00 40 	be  4000a8ec <_Heap_Walk+0x478>                
4000a7f0:	96 15 23 f8 	or  %l4, 0x3f8, %o3                            
    block->next,                                                      
    block->next == last_free_block ?                                  
4000a7f4:	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)(                                                         
4000a7f8:	80 a3 00 0f 	cmp  %o4, %o7                                  
4000a7fc:	02 80 00 33 	be  4000a8c8 <_Heap_Walk+0x454>                
4000a800:	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)" : "")          
4000a804:	02 80 00 37 	be  4000a8e0 <_Heap_Walk+0x46c>                
4000a808:	98 15 23 f8 	or  %l4, 0x3f8, %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)(                                                         
4000a80c:	d6 23 a0 5c 	st  %o3, [ %sp + 0x5c ]                        
4000a810:	d8 23 a0 64 	st  %o4, [ %sp + 0x64 ]                        
4000a814:	de 23 a0 60 	st  %o7, [ %sp + 0x60 ]                        
4000a818:	90 10 00 19 	mov  %i1, %o0                                  
4000a81c:	92 10 20 00 	clr  %o1                                       
4000a820:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a824:	96 10 00 15 	mov  %l5, %o3                                  
4000a828:	94 12 a3 88 	or  %o2, 0x388, %o2                            
4000a82c:	9f c5 c0 00 	call  %l7                                      
4000a830:	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 ) {                        
4000a834:	da 07 40 00 	ld  [ %i5 ], %o5                               
4000a838:	80 a5 80 0d 	cmp  %l6, %o5                                  
4000a83c:	12 80 00 19 	bne  4000a8a0 <_Heap_Walk+0x42c>               
4000a840:	80 a6 a0 00 	cmp  %i2, 0                                    
    );                                                                
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
4000a844:	02 80 00 2d 	be  4000a8f8 <_Heap_Walk+0x484>                
4000a848:	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;                            
4000a84c:	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 ) {                            
4000a850:	80 a6 00 02 	cmp  %i0, %g2                                  
4000a854:	02 80 00 0b 	be  4000a880 <_Heap_Walk+0x40c>                <== NEVER TAKEN
4000a858:	92 10 20 01 	mov  1, %o1                                    
    if ( free_block == block ) {                                      
4000a85c:	80 a5 40 02 	cmp  %l5, %g2                                  
4000a860:	02 bf ff bd 	be  4000a754 <_Heap_Walk+0x2e0>                
4000a864:	80 a7 00 1d 	cmp  %i4, %i5                                  
      return true;                                                    
    }                                                                 
    free_block = free_block->next;                                    
4000a868:	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 ) {                            
4000a86c:	80 a6 00 02 	cmp  %i0, %g2                                  
4000a870:	12 bf ff fc 	bne  4000a860 <_Heap_Walk+0x3ec>               
4000a874:	80 a5 40 02 	cmp  %l5, %g2                                  
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {                 
    (*printer)(                                                       
4000a878:	90 10 00 19 	mov  %i1, %o0                                  
4000a87c:	92 10 20 01 	mov  1, %o1                                    
4000a880:	15 10 00 5f 	sethi  %hi(0x40017c00), %o2                    
4000a884:	96 10 00 15 	mov  %l5, %o3                                  
4000a888:	9f c5 c0 00 	call  %l7                                      
4000a88c:	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;                                                     
4000a890:	10 bf ff 42 	b  4000a598 <_Heap_Walk+0x124>                 
4000a894:	82 10 20 00 	clr  %g1                                       
    }                                                                 
                                                                      
    block = next_block;                                               
  } while ( block != first_block );                                   
                                                                      
  return true;                                                        
4000a898:	10 bf ff 05 	b  4000a4ac <_Heap_Walk+0x38>                  
4000a89c:	82 10 20 01 	mov  1, %g1                                    
      " (= last free)"                                                
        : (block->next == free_list_tail ? " (= tail)" : "")          
  );                                                                  
                                                                      
  if ( block_size != next_block->prev_size ) {                        
    (*printer)(                                                       
4000a8a0:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
4000a8a4:	90 10 00 19 	mov  %i1, %o0                                  
4000a8a8:	92 10 20 01 	mov  1, %o1                                    
4000a8ac:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a8b0:	96 10 00 15 	mov  %l5, %o3                                  
4000a8b4:	94 12 a3 c0 	or  %o2, 0x3c0, %o2                            
4000a8b8:	9f c5 c0 00 	call  %l7                                      
4000a8bc:	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;                                                     
4000a8c0:	10 bf ff 36 	b  4000a598 <_Heap_Walk+0x124>                 
4000a8c4:	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)(                                                         
4000a8c8:	03 10 00 5e 	sethi  %hi(0x40017800), %g1                    
4000a8cc:	10 bf ff d0 	b  4000a80c <_Heap_Walk+0x398>                 
4000a8d0:	98 10 60 50 	or  %g1, 0x50, %o4	! 40017850 <__log2table+0x140>
4000a8d4:	03 10 00 5e 	sethi  %hi(0x40017800), %g1                    
4000a8d8:	10 bf ff c7 	b  4000a7f4 <_Heap_Walk+0x380>                 
4000a8dc:	96 10 60 30 	or  %g1, 0x30, %o3	! 40017830 <__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)" : "")          
4000a8e0:	03 10 00 5e 	sethi  %hi(0x40017800), %g1                    
4000a8e4:	10 bf ff ca 	b  4000a80c <_Heap_Walk+0x398>                 
4000a8e8:	98 10 60 60 	or  %g1, 0x60, %o4	! 40017860 <__log2table+0x150>
    block,                                                            
    block_size,                                                       
    block->prev,                                                      
    block->prev == first_free_block ?                                 
      " (= first free)"                                               
        : (block->prev == free_list_head ? " (= head)" : ""),         
4000a8ec:	17 10 00 5e 	sethi  %hi(0x40017800), %o3                    
4000a8f0:	10 bf ff c1 	b  4000a7f4 <_Heap_Walk+0x380>                 
4000a8f4:	96 12 e0 40 	or  %o3, 0x40, %o3	! 40017840 <__log2table+0x130>
                                                                      
    return false;                                                     
  }                                                                   
                                                                      
  if ( !prev_used ) {                                                 
    (*printer)(                                                       
4000a8f8:	92 10 20 01 	mov  1, %o1                                    
4000a8fc:	15 10 00 5f 	sethi  %hi(0x40017c00), %o2                    
4000a900:	96 10 00 15 	mov  %l5, %o3                                  
4000a904:	9f c5 c0 00 	call  %l7                                      
4000a908:	94 12 a0 00 	mov  %o2, %o2                                  
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000a90c:	10 bf ff 23 	b  4000a598 <_Heap_Walk+0x124>                 
4000a910:	82 10 20 00 	clr  %g1                                       
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( block_size < min_block_size && is_not_last_block ) {         
4000a914:	02 bf ff 9a 	be  4000a77c <_Heap_Walk+0x308>                <== NEVER TAKEN
4000a918:	80 a5 40 1d 	cmp  %l5, %i5                                  
      (*printer)(                                                     
4000a91c:	90 10 00 19 	mov  %i1, %o0                                  
4000a920:	92 10 20 01 	mov  1, %o1                                    
4000a924:	96 10 00 15 	mov  %l5, %o3                                  
4000a928:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a92c:	98 10 00 16 	mov  %l6, %o4                                  
4000a930:	94 12 a3 20 	or  %o2, 0x320, %o2                            
4000a934:	9f c5 c0 00 	call  %l7                                      
4000a938:	9a 10 00 10 	mov  %l0, %o5                                  
        block,                                                        
        block_size,                                                   
        min_block_size                                                
      );                                                              
                                                                      
      return false;                                                   
4000a93c:	10 bf fe dc 	b  4000a4ac <_Heap_Walk+0x38>                  
4000a940:	82 10 20 00 	clr  %g1                                       
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
      (*printer)(                                                     
4000a944:	92 10 20 01 	mov  1, %o1                                    
4000a948:	96 10 00 15 	mov  %l5, %o3                                  
4000a94c:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000a950:	98 10 00 16 	mov  %l6, %o4                                  
4000a954:	9f c5 c0 00 	call  %l7                                      
4000a958:	94 12 a2 f0 	or  %o2, 0x2f0, %o2                            
        "block 0x%08x: block size %u not page aligned\n",             
        block,                                                        
        block_size                                                    
      );                                                              
                                                                      
      return false;                                                   
4000a95c:	10 bf fe d4 	b  4000a4ac <_Heap_Walk+0x38>                  
4000a960:	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;             
4000a964:	80 a4 c0 1d 	cmp  %l3, %i5                                  
4000a968:	0a bf ff 43 	bcs  4000a674 <_Heap_Walk+0x200>               <== NEVER TAKEN
4000a96c:	90 10 00 19 	mov  %i1, %o0                                  
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
4000a970:	da 27 bf fc 	st  %o5, [ %fp + -4 ]                          
4000a974:	90 07 60 08 	add  %i5, 8, %o0                               
4000a978:	7f ff dc 7e 	call  40001b70 <.urem>                         
4000a97c:	92 10 00 14 	mov  %l4, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
4000a980:	80 a2 20 00 	cmp  %o0, 0                                    
4000a984:	12 80 00 36 	bne  4000aa5c <_Heap_Walk+0x5e8>               <== NEVER TAKEN
4000a988:	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;                
4000a98c:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
4000a990:	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;                 
4000a994:	82 07 40 01 	add  %i5, %g1, %g1                             
4000a998:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
4000a99c:	80 88 60 01 	btst  1, %g1                                   
4000a9a0:	12 80 00 27 	bne  4000aa3c <_Heap_Walk+0x5c8>               <== NEVER TAKEN
4000a9a4:	a4 10 00 1d 	mov  %i5, %l2                                  
4000a9a8:	10 80 00 19 	b  4000aa0c <_Heap_Walk+0x598>                 
4000a9ac:	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 ) {                            
4000a9b0:	80 a6 00 1d 	cmp  %i0, %i5                                  
4000a9b4:	02 bf ff 37 	be  4000a690 <_Heap_Walk+0x21c>                
4000a9b8:	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;             
4000a9bc:	0a bf ff 2e 	bcs  4000a674 <_Heap_Walk+0x200>               
4000a9c0:	90 10 00 19 	mov  %i1, %o0                                  
4000a9c4:	80 a7 40 13 	cmp  %i5, %l3                                  
4000a9c8:	18 bf ff 2c 	bgu  4000a678 <_Heap_Walk+0x204>               <== NEVER TAKEN
4000a9cc:	92 10 20 01 	mov  1, %o1                                    
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(                           
  uintptr_t value,                                                    
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return (value % alignment) == 0;                                    
4000a9d0:	da 27 bf fc 	st  %o5, [ %fp + -4 ]                          
4000a9d4:	90 07 60 08 	add  %i5, 8, %o0                               
4000a9d8:	7f ff dc 66 	call  40001b70 <.urem>                         
4000a9dc:	92 10 00 14 	mov  %l4, %o1                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if (                                                              
4000a9e0:	80 a2 20 00 	cmp  %o0, 0                                    
4000a9e4:	12 80 00 1e 	bne  4000aa5c <_Heap_Walk+0x5e8>               
4000a9e8:	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;                
4000a9ec:	de 07 60 04 	ld  [ %i5 + 4 ], %o7                           
4000a9f0:	82 10 00 12 	mov  %l2, %g1                                  
4000a9f4:	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;                 
4000a9f8:	9e 03 c0 1d 	add  %o7, %i5, %o7                             
4000a9fc:	de 03 e0 04 	ld  [ %o7 + 4 ], %o7                           
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
4000aa00:	80 8b e0 01 	btst  1, %o7                                   
4000aa04:	12 80 00 0e 	bne  4000aa3c <_Heap_Walk+0x5c8>               
4000aa08:	a4 10 00 1d 	mov  %i5, %l2                                  
      );                                                              
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( free_block->prev != prev_block ) {                           
4000aa0c:	d8 07 60 0c 	ld  [ %i5 + 0xc ], %o4                         
4000aa10:	80 a3 00 01 	cmp  %o4, %g1                                  
4000aa14:	22 bf ff e7 	be,a   4000a9b0 <_Heap_Walk+0x53c>             
4000aa18:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
      (*printer)(                                                     
4000aa1c:	90 10 00 19 	mov  %i1, %o0                                  
4000aa20:	92 10 20 01 	mov  1, %o1                                    
4000aa24:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000aa28:	96 10 00 1d 	mov  %i5, %o3                                  
4000aa2c:	9f c5 c0 00 	call  %l7                                      
4000aa30:	94 12 a2 88 	or  %o2, 0x288, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000aa34:	10 bf fe d9 	b  4000a598 <_Heap_Walk+0x124>                 
4000aa38:	82 10 20 00 	clr  %g1                                       
                                                                      
      return false;                                                   
    }                                                                 
                                                                      
    if ( _Heap_Is_used( free_block ) ) {                              
      (*printer)(                                                     
4000aa3c:	90 10 00 19 	mov  %i1, %o0                                  
4000aa40:	92 10 20 01 	mov  1, %o1                                    
4000aa44:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000aa48:	96 10 00 1d 	mov  %i5, %o3                                  
4000aa4c:	9f c5 c0 00 	call  %l7                                      
4000aa50:	94 12 a2 68 	or  %o2, 0x268, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000aa54:	10 bf fe d1 	b  4000a598 <_Heap_Walk+0x124>                 
4000aa58:	82 10 20 00 	clr  %g1                                       
    }                                                                 
                                                                      
    if (                                                              
      !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
    ) {                                                               
      (*printer)(                                                     
4000aa5c:	90 10 00 19 	mov  %i1, %o0                                  
4000aa60:	92 10 20 01 	mov  1, %o1                                    
4000aa64:	15 10 00 5e 	sethi  %hi(0x40017800), %o2                    
4000aa68:	96 10 00 1d 	mov  %i5, %o3                                  
4000aa6c:	9f c5 c0 00 	call  %l7                                      
4000aa70:	94 12 a2 38 	or  %o2, 0x238, %o2                            
  if ( !_System_state_Is_up( _System_state_Get() ) ) {                
    return true;                                                      
  }                                                                   
                                                                      
  if ( !_Heap_Walk_check_control( source, printer, heap ) ) {         
    return false;                                                     
4000aa74:	10 bf fe c9 	b  4000a598 <_Heap_Walk+0x124>                 
4000aa78:	82 10 20 00 	clr  %g1                                       
                                                                      

40008e14 <_IO_Initialize_all_drivers>: _IO_Driver_address_table[index] = driver_table[index]; } void _IO_Initialize_all_drivers( void ) {
40008e14:	9d e3 bf a0 	save  %sp, -96, %sp                            
   rtems_device_major_number major;                                   
                                                                      
   for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )         
40008e18:	39 10 00 83 	sethi  %hi(0x40020c00), %i4                    
40008e1c:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1	! 40020c08 <_IO_Number_of_drivers>
40008e20:	ba 10 20 00 	clr  %i5                                       
40008e24:	80 a0 60 00 	cmp  %g1, 0                                    
40008e28:	02 80 00 0b 	be  40008e54 <_IO_Initialize_all_drivers+0x40> <== NEVER TAKEN
40008e2c:	b8 17 20 08 	or  %i4, 8, %i4                                
     (void) rtems_io_initialize( major, 0, NULL );                    
40008e30:	90 10 00 1d 	mov  %i5, %o0                                  
40008e34:	92 10 20 00 	clr  %o1                                       
40008e38:	40 00 15 c1 	call  4000e53c <rtems_io_initialize>           
40008e3c:	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 ++ )         
40008e40:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40008e44:	ba 07 60 01 	inc  %i5                                       
40008e48:	80 a0 40 1d 	cmp  %g1, %i5                                  
40008e4c:	18 bf ff fa 	bgu  40008e34 <_IO_Initialize_all_drivers+0x20>
40008e50:	90 10 00 1d 	mov  %i5, %o0                                  
40008e54:	81 c7 e0 08 	ret                                            
40008e58:	81 e8 00 00 	restore                                        
                                                                      

40008d44 <_IO_Manager_initialization>: #include <rtems/score/wkspace.h> #include <string.h> void _IO_Manager_initialization(void) {
40008d44:	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();  
40008d48:	03 10 00 75 	sethi  %hi(0x4001d400), %g1                    
40008d4c:	82 10 62 18 	or  %g1, 0x218, %g1	! 4001d618 <Configuration> 
  drivers_in_table  = rtems_configuration_get_number_of_device_drivers();
40008d50:	f8 00 60 38 	ld  [ %g1 + 0x38 ], %i4                        
  number_of_drivers = rtems_configuration_get_maximum_drivers();      
40008d54:	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 )                        
40008d58:	80 a7 00 1b 	cmp  %i4, %i3                                  
40008d5c:	0a 80 00 08 	bcs  40008d7c <_IO_Manager_initialization+0x38>
40008d60:	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;                          
40008d64:	03 10 00 83 	sethi  %hi(0x40020c00), %g1                    
40008d68:	fa 20 60 0c 	st  %i5, [ %g1 + 0xc ]	! 40020c0c <_IO_Driver_address_table>
    _IO_Number_of_drivers = number_of_drivers;                        
40008d6c:	03 10 00 83 	sethi  %hi(0x40020c00), %g1                    
40008d70:	f8 20 60 08 	st  %i4, [ %g1 + 8 ]	! 40020c08 <_IO_Number_of_drivers>
    return;                                                           
40008d74:	81 c7 e0 08 	ret                                            
40008d78:	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 )  
40008d7c:	83 2e e0 03 	sll  %i3, 3, %g1                               
40008d80:	b5 2e e0 05 	sll  %i3, 5, %i2                               
40008d84:	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(                             
40008d88:	40 00 0d 2f 	call  4000c244 <_Workspace_Allocate_or_fatal_error>
40008d8c:	90 10 00 1a 	mov  %i2, %o0                                  
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
40008d90:	03 10 00 83 	sethi  %hi(0x40020c00), %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 *)           
40008d94:	33 10 00 83 	sethi  %hi(0x40020c00), %i1                    
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
40008d98:	f6 20 60 08 	st  %i3, [ %g1 + 8 ]                           
  /*                                                                  
   *  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 *)           
40008d9c:	d0 26 60 0c 	st  %o0, [ %i1 + 0xc ]                         
      _Workspace_Allocate_or_fatal_error(                             
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )  
      );                                                              
  _IO_Number_of_drivers = number_of_drivers;                          
                                                                      
  memset(                                                             
40008da0:	92 10 20 00 	clr  %o1                                       
40008da4:	40 00 21 75 	call  40011378 <memset>                        
40008da8:	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++ )              
40008dac:	80 a7 20 00 	cmp  %i4, 0                                    
40008db0:	02 bf ff f1 	be  40008d74 <_IO_Manager_initialization+0x30> <== NEVER TAKEN
40008db4:	c8 06 60 0c 	ld  [ %i1 + 0xc ], %g4                         
#include <rtems/score/thread.h>                                       
#include <rtems/score/wkspace.h>                                      
                                                                      
#include <string.h>                                                   
                                                                      
void _IO_Manager_initialization(void)                                 
40008db8:	85 2f 20 03 	sll  %i4, 3, %g2                               
40008dbc:	b7 2f 20 05 	sll  %i4, 5, %i3                               
40008dc0:	82 10 20 00 	clr  %g1                                       
40008dc4:	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];            
40008dc8:	c4 07 40 01 	ld  [ %i5 + %g1 ], %g2                         
40008dcc:	86 07 40 01 	add  %i5, %g1, %g3                             
40008dd0:	c4 21 00 01 	st  %g2, [ %g4 + %g1 ]                         
40008dd4:	f8 00 e0 04 	ld  [ %g3 + 4 ], %i4                           
40008dd8:	84 01 00 01 	add  %g4, %g1, %g2                             
40008ddc:	f8 20 a0 04 	st  %i4, [ %g2 + 4 ]                           
40008de0:	f8 00 e0 08 	ld  [ %g3 + 8 ], %i4                           
40008de4:	82 00 60 18 	add  %g1, 0x18, %g1                            
40008de8:	f8 20 a0 08 	st  %i4, [ %g2 + 8 ]                           
40008dec:	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++ )              
40008df0:	80 a0 40 1b 	cmp  %g1, %i3                                  
    _IO_Driver_address_table[index] = driver_table[index];            
40008df4:	f8 20 a0 0c 	st  %i4, [ %g2 + 0xc ]                         
40008df8:	f8 00 e0 10 	ld  [ %g3 + 0x10 ], %i4                        
40008dfc:	f8 20 a0 10 	st  %i4, [ %g2 + 0x10 ]                        
40008e00:	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++ )              
40008e04:	12 bf ff f1 	bne  40008dc8 <_IO_Manager_initialization+0x84>
40008e08:	c6 20 a0 14 	st  %g3, [ %g2 + 0x14 ]                        
40008e0c:	81 c7 e0 08 	ret                                            
40008e10:	81 e8 00 00 	restore                                        
                                                                      

40009b0c <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) {
40009b0c:	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 );   
40009b10:	13 10 00 2f 	sethi  %hi(0x4000bc00), %o1                    
40009b14:	90 07 bf f4 	add  %fp, -12, %o0                             
40009b18:	92 12 60 7c 	or  %o1, 0x7c, %o1                             
  Internal_errors_Source source,                                      
  bool                   is_internal,                                 
  Internal_errors_t      error                                        
)                                                                     
{                                                                     
  User_extensions_Fatal_context ctx = { source, is_internal, error }; 
40009b1c:	f0 27 bf f4 	st  %i0, [ %fp + -12 ]                         
40009b20:	f2 2f bf f8 	stb  %i1, [ %fp + -8 ]                         
                                                                      
  _User_extensions_Iterate( &ctx, _User_extensions_Fatal_visitor );   
40009b24:	40 00 08 61 	call  4000bca8 <_User_extensions_Iterate>      
40009b28:	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;            
40009b2c:	05 10 00 81 	sethi  %hi(0x40020400), %g2                    <== NOT EXECUTED
40009b30:	82 10 a3 ac 	or  %g2, 0x3ac, %g1	! 400207ac <_Internal_errors_What_happened><== NOT EXECUTED
40009b34:	f0 20 a3 ac 	st  %i0, [ %g2 + 0x3ac ]                       <== NOT EXECUTED
  _Internal_errors_What_happened.is_internal = is_internal;           
40009b38:	f2 28 60 04 	stb  %i1, [ %g1 + 4 ]                          <== NOT EXECUTED
  _Internal_errors_What_happened.the_error   = the_error;             
40009b3c:	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;                                      
40009b40:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
40009b44:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    <== NOT EXECUTED
                                                                      
  _System_state_Set( SYSTEM_STATE_FAILED );                           
                                                                      
  _CPU_Fatal_halt( the_error );                                       
40009b48:	7f ff e2 62 	call  400024d0 <sparc_disable_interrupts>      <== NOT EXECUTED
40009b4c:	c4 20 63 b8 	st  %g2, [ %g1 + 0x3b8 ]	! 400207b8 <_System_state_Current><== NOT EXECUTED
40009b50:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
40009b54:	30 80 00 00 	b,a   40009b54 <_Internal_error_Occurred+0x48> <== NOT EXECUTED
                                                                      

40009bc4 <_Objects_Allocate>: #endif Objects_Control *_Objects_Allocate( Objects_Information *information ) {
40009bc4:	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 )                                       
40009bc8:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
40009bcc:	80 a0 60 00 	cmp  %g1, 0                                    
40009bd0:	02 80 00 26 	be  40009c68 <_Objects_Allocate+0xa4>          <== NEVER TAKEN
40009bd4:	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 );
40009bd8:	b8 06 20 20 	add  %i0, 0x20, %i4                            
40009bdc:	7f ff fd 4c 	call  4000910c <_Chain_Get>                    
40009be0:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  if ( information->auto_extend ) {                                   
40009be4:	c2 0f 60 12 	ldub  [ %i5 + 0x12 ], %g1                      
40009be8:	80 a0 60 00 	cmp  %g1, 0                                    
40009bec:	02 80 00 16 	be  40009c44 <_Objects_Allocate+0x80>          
40009bf0:	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 ) {                                              
40009bf4:	80 a2 20 00 	cmp  %o0, 0                                    
40009bf8:	02 80 00 15 	be  40009c4c <_Objects_Allocate+0x88>          
40009bfc:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    if ( the_object ) {                                               
      uint32_t   block;                                               
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
40009c00:	c4 07 60 08 	ld  [ %i5 + 8 ], %g2                           
40009c04:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
40009c08:	d2 17 60 14 	lduh  [ %i5 + 0x14 ], %o1                      
    }                                                                 
                                                                      
    if ( the_object ) {                                               
      uint32_t   block;                                               
                                                                      
      block = (uint32_t) _Objects_Get_index( the_object->id ) -       
40009c0c:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
40009c10:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! ffff <PROM_START+0xffff> 
40009c14:	90 0a 00 01 	and  %o0, %g1, %o0                             
40009c18:	82 08 80 01 	and  %g2, %g1, %g1                             
              _Objects_Get_index( information->minimum_id );          
      block /= information->allocation_size;                          
40009c1c:	40 00 3f 96 	call  40019a74 <.udiv>                         
40009c20:	90 22 00 01 	sub  %o0, %g1, %o0                             
                                                                      
      information->inactive_per_block[ block ]--;                     
40009c24:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        
40009c28:	91 2a 20 02 	sll  %o0, 2, %o0                               
40009c2c:	c6 00 40 08 	ld  [ %g1 + %o0 ], %g3                         
      information->inactive--;                                        
40009c30:	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 ]--;                     
40009c34:	86 00 ff ff 	add  %g3, -1, %g3                              
40009c38:	c6 20 40 08 	st  %g3, [ %g1 + %o0 ]                         
      information->inactive--;                                        
40009c3c:	82 00 bf ff 	add  %g2, -1, %g1                              
40009c40:	c2 37 60 2c 	sth  %g1, [ %i5 + 0x2c ]                       
    );                                                                
  }                                                                   
#endif                                                                
                                                                      
  return the_object;                                                  
}                                                                     
40009c44:	81 c7 e0 08 	ret                                            
40009c48:	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 );                     
40009c4c:	40 00 00 10 	call  40009c8c <_Objects_Extend_information>   
40009c50:	90 10 00 1d 	mov  %i5, %o0                                  
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
40009c54:	7f ff fd 2e 	call  4000910c <_Chain_Get>                    
40009c58:	90 10 00 1c 	mov  %i4, %o0                                  
    }                                                                 
                                                                      
    if ( the_object ) {                                               
40009c5c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40009c60:	32 bf ff e9 	bne,a   40009c04 <_Objects_Allocate+0x40>      
40009c64:	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;                                                      
40009c68:	81 c7 e0 08 	ret                                            
40009c6c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40009c8c <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) {
40009c8c:	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 )                           
40009c90:	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 );      
40009c94:	e0 16 20 0a 	lduh  [ %i0 + 0xa ], %l0                       
  index_base    = minimum_index;                                      
  block         = 0;                                                  
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
40009c98:	80 a6 60 00 	cmp  %i1, 0                                    
40009c9c:	02 80 00 a1 	be  40009f20 <_Objects_Extend_information+0x294>
40009ca0:	e2 16 20 10 	lduh  [ %i0 + 0x10 ], %l1                      
    block_count = 0;                                                  
  else {                                                              
    block_count = information->maximum / information->allocation_size;
40009ca4:	f6 16 20 14 	lduh  [ %i0 + 0x14 ], %i3                      
40009ca8:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
40009cac:	92 10 00 1b 	mov  %i3, %o1                                  
40009cb0:	40 00 3f 71 	call  40019a74 <.udiv>                         
40009cb4:	91 34 60 10 	srl  %l1, 0x10, %o0                            
40009cb8:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40009cbc:	b5 32 20 10 	srl  %o0, 0x10, %i2                            
                                                                      
    for ( ; block < block_count; block++ ) {                          
40009cc0:	80 a6 a0 00 	cmp  %i2, 0                                    
40009cc4:	02 80 00 af 	be  40009f80 <_Objects_Extend_information+0x2f4><== NEVER TAKEN
40009cc8:	90 10 00 1b 	mov  %i3, %o0                                  
      if ( information->object_blocks[ block ] == NULL ) {            
40009ccc:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40009cd0:	80 a0 60 00 	cmp  %g1, 0                                    
40009cd4:	02 80 00 b1 	be  40009f98 <_Objects_Extend_information+0x30c><== NEVER TAKEN
40009cd8:	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;                                                  
40009cdc:	10 80 00 06 	b  40009cf4 <_Objects_Extend_information+0x68> 
40009ce0:	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 ) {            
40009ce4:	c2 06 40 01 	ld  [ %i1 + %g1 ], %g1                         
40009ce8:	80 a0 60 00 	cmp  %g1, 0                                    
40009cec:	22 80 00 08 	be,a   40009d0c <_Objects_Extend_information+0x80>
40009cf0:	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++ ) {                          
40009cf4:	ba 07 60 01 	inc  %i5                                       
      if ( information->object_blocks[ block ] == NULL ) {            
        do_extend = false;                                            
        break;                                                        
      } else                                                          
        index_base += information->allocation_size;                   
40009cf8:	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++ ) {                          
40009cfc:	80 a6 80 1d 	cmp  %i2, %i5                                  
40009d00:	18 bf ff f9 	bgu  40009ce4 <_Objects_Extend_information+0x58>
40009d04:	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;                                               
40009d08:	b6 10 20 01 	mov  1, %i3                                    
      } else                                                          
        index_base += information->allocation_size;                   
    }                                                                 
  }                                                                   
                                                                      
  maximum = (uint32_t) information->maximum + information->allocation_size;
40009d0c:	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 ) {                           
40009d10:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
      } else                                                          
        index_base += information->allocation_size;                   
    }                                                                 
  }                                                                   
                                                                      
  maximum = (uint32_t) information->maximum + information->allocation_size;
40009d14:	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 ) {                           
40009d18:	82 10 63 ff 	or  %g1, 0x3ff, %g1                            
40009d1c:	80 a6 40 01 	cmp  %i1, %g1                                  
40009d20:	18 80 00 9c 	bgu  40009f90 <_Objects_Extend_information+0x304>
40009d24:	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;      
40009d28:	40 00 3f 19 	call  4001998c <.umul>                         
40009d2c:	d2 06 20 18 	ld  [ %i0 + 0x18 ], %o1                        
  if ( information->auto_extend ) {                                   
40009d30:	c2 0e 20 12 	ldub  [ %i0 + 0x12 ], %g1                      
40009d34:	80 a0 60 00 	cmp  %g1, 0                                    
40009d38:	02 80 00 6d 	be  40009eec <_Objects_Extend_information+0x260>
40009d3c:	01 00 00 00 	nop                                            
    new_object_block = _Workspace_Allocate( block_size );             
40009d40:	40 00 09 33 	call  4000c20c <_Workspace_Allocate>           
40009d44:	01 00 00 00 	nop                                            
    if ( !new_object_block )                                          
40009d48:	a2 92 20 00 	orcc  %o0, 0, %l1                              
40009d4c:	02 80 00 91 	be  40009f90 <_Objects_Extend_information+0x304>
40009d50:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Do we need to grow the tables?                                  
   */                                                                 
  if ( do_extend ) {                                                  
40009d54:	80 8e e0 ff 	btst  0xff, %i3                                
40009d58:	22 80 00 42 	be,a   40009e60 <_Objects_Extend_information+0x1d4>
40009d5c:	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 ) {                                 
40009d60:	c2 0e 20 12 	ldub  [ %i0 + 0x12 ], %g1                      
     */                                                               
                                                                      
    /*                                                                
     *  Up the block count and maximum                                
     */                                                               
    block_count++;                                                    
40009d64:	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 ) {                                 
40009d68:	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 *)) +
40009d6c:	91 2e e0 01 	sll  %i3, 1, %o0                               
40009d70:	90 02 00 1b 	add  %o0, %i3, %o0                             
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
40009d74:	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 *)) +
40009d78:	90 02 00 10 	add  %o0, %l0, %o0                             
          ((maximum + minimum_index) * sizeof(Objects_Control *));    
    if ( information->auto_extend ) {                                 
40009d7c:	12 80 00 60 	bne  40009efc <_Objects_Extend_information+0x270>
40009d80:	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 );
40009d84:	40 00 09 30 	call  4000c244 <_Workspace_Allocate_or_fatal_error>
40009d88:	01 00 00 00 	nop                                            
40009d8c:	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 ) {                     
40009d90:	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*) );                 
40009d94:	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 ) {                     
40009d98:	80 a4 00 01 	cmp  %l0, %g1                                  
40009d9c:	a6 04 80 1b 	add  %l2, %i3, %l3                             
40009da0:	0a 80 00 67 	bcs  40009f3c <_Objects_Extend_information+0x2b0>
40009da4:	b6 04 c0 1b 	add  %l3, %i3, %i3                             
 *    information     - object information table                      
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
40009da8:	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++ ) {             
40009dac:	80 a4 20 00 	cmp  %l0, 0                                    
40009db0:	02 80 00 07 	be  40009dcc <_Objects_Extend_information+0x140><== NEVER TAKEN
40009db4:	82 10 20 00 	clr  %g1                                       
        local_table[ index ] = NULL;                                  
40009db8:	c0 20 40 1b 	clr  [ %g1 + %i3 ]                             
40009dbc:	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++ ) {             
40009dc0:	80 a0 40 02 	cmp  %g1, %g2                                  
40009dc4:	32 bf ff fe 	bne,a   40009dbc <_Objects_Extend_information+0x130><== NEVER TAKEN
40009dc8:	c0 20 40 1b 	clr  [ %g1 + %i3 ]                             <== NOT EXECUTED
40009dcc:	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 );      
40009dd0:	c6 16 20 14 	lduh  [ %i0 + 0x14 ], %g3                      
    }                                                                 
                                                                      
    /*                                                                
     *  Initialise the new entries in the table.                      
     */                                                               
    object_blocks[block_count] = NULL;                                
40009dd4:	c0 24 80 1a 	clr  [ %l2 + %i2 ]                             
    inactive_per_block[block_count] = 0;                              
                                                                      
    for ( index=index_base ;                                          
          index < ( information->allocation_size + index_base );      
40009dd8:	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 ;                                          
40009ddc:	80 a7 00 01 	cmp  %i4, %g1                                  
40009de0:	1a 80 00 0b 	bcc  40009e0c <_Objects_Extend_information+0x180><== NEVER TAKEN
40009de4:	c0 24 c0 1a 	clr  [ %l3 + %i2 ]                             
 *    information     - object information table                      
 *                                                                    
 *  Output parameters:  NONE                                          
 */                                                                   
                                                                      
void _Objects_Extend_information(                                     
40009de8:	85 2f 20 02 	sll  %i4, 2, %g2                               
40009dec:	87 28 e0 02 	sll  %g3, 2, %g3                               
40009df0:	84 06 c0 02 	add  %i3, %g2, %g2                             
40009df4:	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;                                    
40009df8:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
40009dfc:	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 ;                                          
40009e00:	80 a0 40 03 	cmp  %g1, %g3                                  
40009e04:	32 bf ff fe 	bne,a   40009dfc <_Objects_Extend_information+0x170>
40009e08:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
          index < ( information->allocation_size + index_base );      
          index++ ) {                                                 
      local_table[ index ] = NULL;                                    
    }                                                                 
                                                                      
    _ISR_Disable( level );                                            
40009e0c:	7f ff e1 b1 	call  400024d0 <sparc_disable_interrupts>      
40009e10:	01 00 00 00 	nop                                            
  uint32_t         the_class,                                         
  uint32_t         node,                                              
  uint32_t         index                                              
)                                                                     
{                                                                     
  return (( (Objects_Id) the_api )   << OBJECTS_API_START_BIT)   |    
40009e14:	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(                      
40009e18:	c4 16 20 04 	lduh  [ %i0 + 4 ], %g2                         
      local_table[ index ] = NULL;                                    
    }                                                                 
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
40009e1c:	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;                 
40009e20:	f2 36 20 10 	sth  %i1, [ %i0 + 0x10 ]                       
40009e24:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40009e28:	85 28 a0 1b 	sll  %g2, 0x1b, %g2                            
                                                                      
    _ISR_Disable( level );                                            
                                                                      
    old_tables = information->object_blocks;                          
                                                                      
    information->object_blocks = object_blocks;                       
40009e2c:	e4 26 20 34 	st  %l2, [ %i0 + 0x34 ]                        
    information->inactive_per_block = inactive_per_block;             
40009e30:	e6 26 20 30 	st  %l3, [ %i0 + 0x30 ]                        
    information->local_table = local_table;                           
40009e34:	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)   |    
40009e38:	03 00 00 40 	sethi  %hi(0x10000), %g1                       
40009e3c:	82 10 c0 01 	or  %g3, %g1, %g1                              
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40009e40:	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)   |    
40009e44:	b2 10 40 19 	or  %g1, %i1, %i1                              
    information->maximum = (Objects_Maximum) maximum;                 
    information->maximum_id = _Objects_Build_id(                      
40009e48:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
        information->the_class,                                       
        _Objects_Local_node,                                          
        information->maximum                                          
      );                                                              
                                                                      
    _ISR_Enable( level );                                             
40009e4c:	7f ff e1 a5 	call  400024e0 <sparc_enable_interrupts>       
40009e50:	01 00 00 00 	nop                                            
                                                                      
    _Workspace_Free( old_tables );                                    
40009e54:	40 00 08 f6 	call  4000c22c <_Workspace_Free>               
40009e58:	90 10 00 1a 	mov  %i2, %o0                                  
  }                                                                   
                                                                      
  /*                                                                  
   *  Assign the new object block to the object block table.          
   */                                                                 
  information->object_blocks[ block ] = new_object_block;             
40009e5c:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
40009e60:	bb 2f 60 02 	sll  %i5, 2, %i5                               
40009e64:	e2 20 40 1d 	st  %l1, [ %g1 + %i5 ]                         
                                                                      
  /*                                                                  
   *  Initialize objects .. add to a local chain first.               
   */                                                                 
  _Chain_Initialize(                                                  
40009e68:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
40009e6c:	d4 16 20 14 	lduh  [ %i0 + 0x14 ], %o2                      
40009e70:	d2 00 40 1d 	ld  [ %g1 + %i5 ], %o1                         
40009e74:	d6 06 20 18 	ld  [ %i0 + 0x18 ], %o3                        
40009e78:	90 07 bf f4 	add  %fp, -12, %o0                             
40009e7c:	7f ff fc b4 	call  4000914c <_Chain_Initialize>             
40009e80:	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 ) {
40009e84:	10 80 00 0d 	b  40009eb8 <_Objects_Extend_information+0x22c>
40009e88:	b6 06 20 20 	add  %i0, 0x20, %i3                            
                                                                      
    the_object->id = _Objects_Build_id(                               
40009e8c:	c6 16 20 04 	lduh  [ %i0 + 4 ], %g3                         
40009e90:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40009e94:	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)   |    
40009e98:	84 10 80 1a 	or  %g2, %i2, %g2                              
         (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |    
40009e9c:	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)   |    
40009ea0:	84 10 80 1c 	or  %g2, %i4, %g2                              
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
40009ea4:	90 10 00 1b 	mov  %i3, %o0                                  
40009ea8:	92 10 00 01 	mov  %g1, %o1                                  
                                                                      
    index++;                                                          
40009eac:	b8 07 20 01 	inc  %i4                                       
        information->the_class,                                       
        _Objects_Local_node,                                          
        index                                                         
      );                                                              
                                                                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
40009eb0:	7f ff fc 8c 	call  400090e0 <_Chain_Append>                 
40009eb4:	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 ) {
40009eb8:	7f ff fc 95 	call  4000910c <_Chain_Get>                    
40009ebc:	90 07 bf f4 	add  %fp, -12, %o0                             
40009ec0:	82 92 20 00 	orcc  %o0, 0, %g1                              
40009ec4:	32 bf ff f2 	bne,a   40009e8c <_Objects_Extend_information+0x200>
40009ec8:	c4 06 00 00 	ld  [ %i0 ], %g2                               
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
40009ecc:	c8 16 20 14 	lduh  [ %i0 + 0x14 ], %g4                      
40009ed0:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3                        
  information->inactive =                                             
    (Objects_Maximum)(information->inactive + information->allocation_size);
40009ed4:	c4 16 20 2c 	lduh  [ %i0 + 0x2c ], %g2                      
    _Chain_Append( &information->Inactive, &the_object->Node );       
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
40009ed8:	c8 20 c0 1d 	st  %g4, [ %g3 + %i5 ]                         
  information->inactive =                                             
    (Objects_Maximum)(information->inactive + information->allocation_size);
40009edc:	82 00 80 04 	add  %g2, %g4, %g1                             
                                                                      
    index++;                                                          
  }                                                                   
                                                                      
  information->inactive_per_block[ block ] = information->allocation_size;
  information->inactive =                                             
40009ee0:	c2 36 20 2c 	sth  %g1, [ %i0 + 0x2c ]                       
40009ee4:	81 c7 e0 08 	ret                                            
40009ee8:	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 );
40009eec:	40 00 08 d6 	call  4000c244 <_Workspace_Allocate_or_fatal_error>
40009ef0:	01 00 00 00 	nop                                            
40009ef4:	10 bf ff 98 	b  40009d54 <_Objects_Extend_information+0xc8> 
40009ef8:	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 );              
40009efc:	40 00 08 c4 	call  4000c20c <_Workspace_Allocate>           
40009f00:	01 00 00 00 	nop                                            
      if ( !object_blocks ) {                                         
40009f04:	a4 92 20 00 	orcc  %o0, 0, %l2                              
40009f08:	32 bf ff a3 	bne,a   40009d94 <_Objects_Extend_information+0x108>
40009f0c:	c2 16 20 10 	lduh  [ %i0 + 0x10 ], %g1                      
        _Workspace_Free( new_object_block );                          
40009f10:	40 00 08 c7 	call  4000c22c <_Workspace_Free>               
40009f14:	90 10 00 11 	mov  %l1, %o0                                  
40009f18:	81 c7 e0 08 	ret                                            
40009f1c:	81 e8 00 00 	restore                                        
40009f20:	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 );      
40009f24:	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;                                               
40009f28:	b6 10 20 01 	mov  1, %i3                                    
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
40009f2c:	ba 10 20 00 	clr  %i5                                       
                                                                      
  /* if ( information->maximum < minimum_index ) */                   
  if ( information->object_blocks == NULL )                           
    block_count = 0;                                                  
40009f30:	b4 10 20 00 	clr  %i2                                       
40009f34:	10 bf ff 76 	b  40009d0c <_Objects_Extend_information+0x80> 
40009f38:	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,                                          
40009f3c:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
40009f40:	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,                                          
40009f44:	90 10 00 12 	mov  %l2, %o0                                  
40009f48:	40 00 1c cf 	call  40011284 <memcpy>                        
40009f4c:	94 10 00 1a 	mov  %i2, %o2                                  
              information->object_blocks,                             
              block_count * sizeof(void*) );                          
      memcpy( inactive_per_block,                                     
40009f50:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1                        
40009f54:	94 10 00 1a 	mov  %i2, %o2                                  
40009f58:	40 00 1c cb 	call  40011284 <memcpy>                        
40009f5c:	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 *) );
40009f60:	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,                                            
40009f64:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
              information->local_table,                               
              (information->maximum + minimum_index) * sizeof(Objects_Control *) );
40009f68:	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,                                            
40009f6c:	90 10 00 1b 	mov  %i3, %o0                                  
40009f70:	40 00 1c c5 	call  40011284 <memcpy>                        
40009f74:	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 );      
40009f78:	10 bf ff 97 	b  40009dd4 <_Objects_Extend_information+0x148>
40009f7c:	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 );      
40009f80:	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;                                               
40009f84:	b6 10 20 01 	mov  1, %i3                                    <== NOT EXECUTED
  minimum_index = _Objects_Get_index( information->minimum_id );      
  index_base    = minimum_index;                                      
  block         = 0;                                                  
40009f88:	10 bf ff 61 	b  40009d0c <_Objects_Extend_information+0x80> <== NOT EXECUTED
40009f8c:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
40009f90:	81 c7 e0 08 	ret                                            
40009f94:	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;                                            
40009f98:	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;                                                  
40009f9c:	10 bf ff 5c 	b  40009d0c <_Objects_Extend_information+0x80> <== NOT EXECUTED
40009fa0:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
                                                                      

4000a054 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) {
4000a054:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
4000a058:	80 a6 60 00 	cmp  %i1, 0                                    
4000a05c:	02 80 00 19 	be  4000a0c0 <_Objects_Get_information+0x6c>   
4000a060:	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 );      
4000a064:	40 00 12 b2 	call  4000eb2c <_Objects_API_maximum_class>    
4000a068:	90 10 00 18 	mov  %i0, %o0                                  
  if ( the_class_api_maximum == 0 )                                   
4000a06c:	80 a2 20 00 	cmp  %o0, 0                                    
4000a070:	02 80 00 14 	be  4000a0c0 <_Objects_Get_information+0x6c>   
4000a074:	80 a2 00 19 	cmp  %o0, %i1                                  
    return NULL;                                                      
                                                                      
  if ( the_class > (uint32_t) the_class_api_maximum )                 
4000a078:	0a 80 00 12 	bcs  4000a0c0 <_Objects_Get_information+0x6c>  
4000a07c:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
    return NULL;                                                      
                                                                      
  if ( !_Objects_Information_table[ the_api ] )                       
4000a080:	b1 2e 20 02 	sll  %i0, 2, %i0                               
4000a084:	82 10 62 14 	or  %g1, 0x214, %g1                            
4000a088:	c2 00 40 18 	ld  [ %g1 + %i0 ], %g1                         
4000a08c:	80 a0 60 00 	cmp  %g1, 0                                    
4000a090:	02 80 00 0c 	be  4000a0c0 <_Objects_Get_information+0x6c>   <== NEVER TAKEN
4000a094:	b3 2e 60 02 	sll  %i1, 2, %i1                               
    return NULL;                                                      
                                                                      
  info = _Objects_Information_table[ the_api ][ the_class ];          
4000a098:	f0 00 40 19 	ld  [ %g1 + %i1 ], %i0                         
  if ( !info )                                                        
4000a09c:	80 a6 20 00 	cmp  %i0, 0                                    
4000a0a0:	02 80 00 08 	be  4000a0c0 <_Objects_Get_information+0x6c>   <== NEVER TAKEN
4000a0a4:	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 )                                         
4000a0a8:	c2 16 20 10 	lduh  [ %i0 + 0x10 ], %g1                      
4000a0ac:	80 a0 60 00 	cmp  %g1, 0                                    
4000a0b0:	02 80 00 04 	be  4000a0c0 <_Objects_Get_information+0x6c>   
4000a0b4:	01 00 00 00 	nop                                            
      return NULL;                                                    
  #endif                                                              
                                                                      
  return info;                                                        
}                                                                     
4000a0b8:	81 c7 e0 08 	ret                                            
4000a0bc:	81 e8 00 00 	restore                                        
{                                                                     
  Objects_Information *info;                                          
  int the_class_api_maximum;                                          
                                                                      
  if ( !the_class )                                                   
    return NULL;                                                      
4000a0c0:	81 c7 e0 08 	ret                                            
4000a0c4:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

400185e8 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) {
400185e8:	9d e3 bf 90 	save  %sp, -112, %sp                           
  char                   lname[5];                                    
  Objects_Control       *the_object;                                  
  Objects_Locations      location;                                    
  Objects_Id             tmpId;                                       
                                                                      
  if ( length == 0 )                                                  
400185ec:	80 a6 60 00 	cmp  %i1, 0                                    
400185f0:	02 80 00 11 	be  40018634 <_Objects_Get_name_as_string+0x4c>
400185f4:	80 a6 a0 00 	cmp  %i2, 0                                    
    return NULL;                                                      
                                                                      
  if ( name == NULL )                                                 
400185f8:	02 80 00 0f 	be  40018634 <_Objects_Get_name_as_string+0x4c>
400185fc:	ba 96 20 00 	orcc  %i0, 0, %i5                              
    return NULL;                                                      
                                                                      
  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
40018600:	02 80 00 3d 	be  400186f4 <_Objects_Get_name_as_string+0x10c>
40018604:	03 10 00 cf 	sethi  %hi(0x40033c00), %g1                    
                                                                      
  information = _Objects_Get_information_id( tmpId );                 
40018608:	7f ff e0 5e 	call  40010780 <_Objects_Get_information_id>   
4001860c:	90 10 00 1d 	mov  %i5, %o0                                  
  if ( !information )                                                 
40018610:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40018614:	02 80 00 08 	be  40018634 <_Objects_Get_name_as_string+0x4c>
40018618:	92 10 00 1d 	mov  %i5, %o1                                  
    return NULL;                                                      
                                                                      
  the_object = _Objects_Get( information, tmpId, &location );         
4001861c:	7f ff e0 99 	call  40010880 <_Objects_Get>                  
40018620:	94 07 bf f4 	add  %fp, -12, %o2                             
  switch ( location ) {                                               
40018624:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40018628:	80 a0 60 00 	cmp  %g1, 0                                    
4001862c:	22 80 00 05 	be,a   40018640 <_Objects_Get_name_as_string+0x58>
40018630:	c2 0f 20 38 	ldub  [ %i4 + 0x38 ], %g1                      
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:                                              
      /* not supported */                                             
#endif                                                                
    case OBJECTS_ERROR:                                               
      return NULL;                                                    
40018634:	b4 10 20 00 	clr  %i2                                       
                                                                      
      _Thread_Enable_dispatch();                                      
      return name;                                                    
  }                                                                   
  return NULL;                  /* unreachable path */                
}                                                                     
40018638:	81 c7 e0 08 	ret                                            
4001863c:	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 ) {                               
40018640:	80 a0 60 00 	cmp  %g1, 0                                    
40018644:	12 80 00 2f 	bne  40018700 <_Objects_Get_name_as_string+0x118>
40018648:	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;                         
4001864c:	89 30 60 18 	srl  %g1, 0x18, %g4                            
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
40018650:	87 30 60 10 	srl  %g1, 0x10, %g3                            
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
40018654:	85 30 60 08 	srl  %g1, 8, %g2                               
        lname[ 3 ] = (u32_name >>  0) & 0xff;                         
40018658:	c2 2f bf fb 	stb  %g1, [ %fp + -5 ]                         
        lname[ 4 ] = '\0';                                            
4001865c:	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;                         
40018660:	c8 2f bf f8 	stb  %g4, [ %fp + -8 ]                         
        lname[ 1 ] = (u32_name >> 16) & 0xff;                         
40018664:	c6 2f bf f9 	stb  %g3, [ %fp + -7 ]                         
        lname[ 2 ] = (u32_name >>  8) & 0xff;                         
40018668:	c4 2f bf fa 	stb  %g2, [ %fp + -6 ]                         
        lname[ 3 ] = (u32_name >>  0) & 0xff;                         
        lname[ 4 ] = '\0';                                            
        s = lname;                                                    
4001866c:	82 07 bf f8 	add  %fp, -8, %g1                              
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
40018670:	80 a6 60 01 	cmp  %i1, 1                                    
40018674:	02 80 00 27 	be  40018710 <_Objects_Get_name_as_string+0x128><== NEVER TAKEN
40018678:	86 10 00 1a 	mov  %i2, %g3                                  
4001867c:	c6 48 40 00 	ldsb  [ %g1 ], %g3                             
40018680:	80 a0 e0 00 	cmp  %g3, 0                                    
40018684:	02 80 00 22 	be  4001870c <_Objects_Get_name_as_string+0x124>
40018688:	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(                                    
4001868c:	b6 06 7f ff 	add  %i1, -1, %i3                              
40018690:	39 10 00 c9 	sethi  %hi(0x40032400), %i4                    
40018694:	b6 00 40 1b 	add  %g1, %i3, %i3                             
40018698:	86 10 00 1a 	mov  %i2, %g3                                  
4001869c:	10 80 00 06 	b  400186b4 <_Objects_Get_name_as_string+0xcc> 
400186a0:	b8 17 20 58 	or  %i4, 0x58, %i4                             
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
400186a4:	c8 48 40 00 	ldsb  [ %g1 ], %g4                             
400186a8:	80 a1 20 00 	cmp  %g4, 0                                    
400186ac:	02 80 00 0e 	be  400186e4 <_Objects_Get_name_as_string+0xfc>
400186b0:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
400186b4:	fa 07 00 00 	ld  [ %i4 ], %i5                               
400186b8:	88 08 a0 ff 	and  %g2, 0xff, %g4                            
400186bc:	88 07 40 04 	add  %i5, %g4, %g4                             
400186c0:	c8 49 20 01 	ldsb  [ %g4 + 1 ], %g4                         
400186c4:	80 89 20 97 	btst  0x97, %g4                                
400186c8:	12 80 00 03 	bne  400186d4 <_Objects_Get_name_as_string+0xec>
400186cc:	82 00 60 01 	inc  %g1                                       
400186d0:	84 10 20 2a 	mov  0x2a, %g2                                 
400186d4:	c4 28 c0 00 	stb  %g2, [ %g3 ]                              
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
400186d8:	80 a0 40 1b 	cmp  %g1, %i3                                  
400186dc:	12 bf ff f2 	bne  400186a4 <_Objects_Get_name_as_string+0xbc>
400186e0:	86 00 e0 01 	inc  %g3                                       
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
        }                                                             
      }                                                               
      *d = '\0';                                                      
                                                                      
      _Thread_Enable_dispatch();                                      
400186e4:	7f ff e4 73 	call  400118b0 <_Thread_Enable_dispatch>       
400186e8:	c0 28 c0 00 	clrb  [ %g3 ]                                  
      return name;                                                    
  }                                                                   
  return NULL;                  /* unreachable path */                
}                                                                     
400186ec:	81 c7 e0 08 	ret                                            
400186f0:	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;
400186f4:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
400186f8:	10 bf ff c4 	b  40018608 <_Objects_Get_name_as_string+0x20> 
400186fc:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
        lname[ 4 ] = '\0';                                            
        s = lname;                                                    
      }                                                               
                                                                      
      d = name;                                                       
      if ( s ) {                                                      
40018700:	80 a0 60 00 	cmp  %g1, 0                                    
40018704:	12 bf ff dc 	bne  40018674 <_Objects_Get_name_as_string+0x8c>
40018708:	80 a6 60 01 	cmp  %i1, 1                                    
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {            
          *d = (isprint((unsigned char)*s)) ? *s : '*';               
4001870c:	86 10 00 1a 	mov  %i2, %g3                                  
        }                                                             
      }                                                               
      *d = '\0';                                                      
                                                                      
      _Thread_Enable_dispatch();                                      
40018710:	7f ff e4 68 	call  400118b0 <_Thread_Enable_dispatch>       
40018714:	c0 28 c0 00 	clrb  [ %g3 ]                                  
40018718:	30 bf ff f5 	b,a   400186ec <_Objects_Get_name_as_string+0x104>
                                                                      

4001b3f8 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) {
4001b3f8:	9d e3 bf a0 	save  %sp, -96, %sp                            
    Objects_Control *object;                                          
    Objects_Id       next_id;                                         
                                                                      
    if ( !information )                                               
4001b3fc:	80 a6 20 00 	cmp  %i0, 0                                    
4001b400:	02 80 00 29 	be  4001b4a4 <_Objects_Get_next+0xac>          
4001b404:	80 a6 a0 00 	cmp  %i2, 0                                    
      return NULL;                                                    
                                                                      
    if ( !location_p )                                                
4001b408:	02 80 00 27 	be  4001b4a4 <_Objects_Get_next+0xac>          
4001b40c:	80 a6 e0 00 	cmp  %i3, 0                                    
      return NULL;                                                    
                                                                      
    if ( !next_id_p )                                                 
4001b410:	02 80 00 25 	be  4001b4a4 <_Objects_Get_next+0xac>          
4001b414:	83 2e 60 10 	sll  %i1, 0x10, %g1                            
      return NULL;                                                    
                                                                      
    if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)           
4001b418:	80 a0 60 00 	cmp  %g1, 0                                    
4001b41c:	22 80 00 13 	be,a   4001b468 <_Objects_Get_next+0x70>       
4001b420:	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)       
4001b424:	c4 16 20 10 	lduh  [ %i0 + 0x10 ], %g2                      
4001b428:	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);      
4001b42c:	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)       
4001b430:	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);      
4001b434:	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)       
4001b438:	80 a0 80 01 	cmp  %g2, %g1                                  
4001b43c:	0a 80 00 13 	bcs  4001b488 <_Objects_Get_next+0x90>         
4001b440:	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);      
4001b444:	7f ff d5 0f 	call  40010880 <_Objects_Get>                  
4001b448:	b2 06 60 01 	inc  %i1                                       
                                                                      
        next_id++;                                                    
                                                                      
    } while (*location_p != OBJECTS_LOCAL);                           
4001b44c:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4001b450:	80 a0 60 00 	cmp  %g1, 0                                    
4001b454:	32 bf ff f5 	bne,a   4001b428 <_Objects_Get_next+0x30>      
4001b458:	c4 16 20 10 	lduh  [ %i0 + 0x10 ], %g2                      
                                                                      
    *next_id_p = next_id;                                             
4001b45c:	f2 26 c0 00 	st  %i1, [ %i3 ]                               
    return object;                                                    
                                                                      
final:                                                                
    *next_id_p = OBJECTS_ID_FINAL;                                    
    return 0;                                                         
}                                                                     
4001b460:	81 c7 e0 08 	ret                                            
4001b464:	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)       
4001b468:	c4 16 20 10 	lduh  [ %i0 + 0x10 ], %g2                      
4001b46c:	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);      
4001b470:	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)       
4001b474:	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);      
4001b478:	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)       
4001b47c:	80 a0 80 01 	cmp  %g2, %g1                                  
4001b480:	1a bf ff f1 	bcc  4001b444 <_Objects_Get_next+0x4c>         <== ALWAYS TAKEN
4001b484:	94 10 00 1a 	mov  %i2, %o2                                  
        {                                                             
            *location_p = OBJECTS_ERROR;                              
4001b488:	82 10 20 01 	mov  1, %g1                                    
4001b48c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    *next_id_p = next_id;                                             
    return object;                                                    
                                                                      
final:                                                                
    *next_id_p = OBJECTS_ID_FINAL;                                    
    return 0;                                                         
4001b490:	90 10 20 00 	clr  %o0                                       
                                                                      
    *next_id_p = next_id;                                             
    return object;                                                    
                                                                      
final:                                                                
    *next_id_p = OBJECTS_ID_FINAL;                                    
4001b494:	82 10 3f ff 	mov  -1, %g1                                   
4001b498:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    return 0;                                                         
}                                                                     
4001b49c:	81 c7 e0 08 	ret                                            
4001b4a0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
{                                                                     
    Objects_Control *object;                                          
    Objects_Id       next_id;                                         
                                                                      
    if ( !information )                                               
      return NULL;                                                    
4001b4a4:	10 bf ff ef 	b  4001b460 <_Objects_Get_next+0x68>           
4001b4a8:	90 10 20 00 	clr  %o0                                       
                                                                      

4001b63c <_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;
4001b63c:	c4 02 20 08 	ld  [ %o0 + 8 ], %g2                           
                                                                      
  if ( information->maximum >= index ) {                              
4001b640:	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;                           
4001b644:	92 22 40 02 	sub  %o1, %g2, %o1                             
4001b648:	92 02 60 01 	inc  %o1                                       
                                                                      
  if ( information->maximum >= index ) {                              
4001b64c:	80 a2 40 01 	cmp  %o1, %g1                                  
4001b650:	18 80 00 09 	bgu  4001b674 <_Objects_Get_no_protection+0x38>
4001b654:	93 2a 60 02 	sll  %o1, 2, %o1                               
    if ( (the_object = information->local_table[ index ]) != NULL ) { 
4001b658:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
4001b65c:	d0 00 40 09 	ld  [ %g1 + %o1 ], %o0                         
4001b660:	80 a2 20 00 	cmp  %o0, 0                                    
4001b664:	02 80 00 05 	be  4001b678 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
4001b668:	82 10 20 01 	mov  1, %g1                                    
      *location = OBJECTS_LOCAL;                                      
      return the_object;                                              
4001b66c:	81 c3 e0 08 	retl                                           
4001b670:	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;                                          
4001b674:	82 10 20 01 	mov  1, %g1                                    
  return NULL;                                                        
4001b678:	90 10 20 00 	clr  %o0                                       
}                                                                     
4001b67c:	81 c3 e0 08 	retl                                           
4001b680:	c2 22 80 00 	st  %g1, [ %o2 ]                               
                                                                      

400108f4 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) {
400108f4:	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;
400108f8:	80 a6 20 00 	cmp  %i0, 0                                    
400108fc:	12 80 00 06 	bne  40010914 <_Objects_Id_to_name+0x20>       
40010900:	83 36 20 18 	srl  %i0, 0x18, %g1                            
40010904:	03 10 00 cf 	sethi  %hi(0x40033c00), %g1                    
40010908:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1	! 40033c10 <_Per_CPU_Information+0x10>
4001090c:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
40010910:	83 36 20 18 	srl  %i0, 0x18, %g1                            
40010914:	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 )                      
40010918:	84 00 7f ff 	add  %g1, -1, %g2                              
4001091c:	80 a0 a0 02 	cmp  %g2, 2                                    
40010920:	18 80 00 11 	bgu  40010964 <_Objects_Id_to_name+0x70>       
40010924:	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 ] )                       
40010928:	05 10 00 cd 	sethi  %hi(0x40033400), %g2                    
4001092c:	84 10 a2 14 	or  %g2, 0x214, %g2	! 40033614 <_Objects_Information_table>
40010930:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
40010934:	80 a0 60 00 	cmp  %g1, 0                                    
40010938:	02 80 00 0b 	be  40010964 <_Objects_Id_to_name+0x70>        
4001093c:	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 ];   
40010940:	85 28 a0 02 	sll  %g2, 2, %g2                               
40010944:	d0 00 40 02 	ld  [ %g1 + %g2 ], %o0                         
  if ( !information )                                                 
40010948:	80 a2 20 00 	cmp  %o0, 0                                    
4001094c:	02 80 00 06 	be  40010964 <_Objects_Id_to_name+0x70>        <== NEVER TAKEN
40010950:	01 00 00 00 	nop                                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)                 
    if ( information->is_string )                                     
40010954:	c2 0a 20 38 	ldub  [ %o0 + 0x38 ], %g1                      
40010958:	80 a0 60 00 	cmp  %g1, 0                                    
4001095c:	02 80 00 04 	be  4001096c <_Objects_Id_to_name+0x78>        <== ALWAYS TAKEN
40010960:	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;                                        
40010964:	81 c7 e0 08 	ret                                            
40010968:	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 ); 
4001096c:	7f ff ff c5 	call  40010880 <_Objects_Get>                  
40010970:	94 07 bf fc 	add  %fp, -4, %o2                              
  if ( !the_object )                                                  
40010974:	80 a2 20 00 	cmp  %o0, 0                                    
40010978:	02 bf ff fb 	be  40010964 <_Objects_Id_to_name+0x70>        
4001097c:	01 00 00 00 	nop                                            
    return OBJECTS_INVALID_ID;                                        
                                                                      
  *name = the_object->name;                                           
40010980:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
  _Thread_Enable_dispatch();                                          
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;                        
40010984:	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();                                          
40010988:	40 00 03 ca 	call  400118b0 <_Thread_Enable_dispatch>       
4001098c:	c2 26 40 00 	st  %g1, [ %i1 ]                               
40010990:	81 c7 e0 08 	ret                                            
40010994:	81 e8 00 00 	restore                                        
                                                                      

4000a364 <_Objects_Shrink_information>: #include <rtems/score/isr.h> void _Objects_Shrink_information( Objects_Information *information ) {
4000a364:	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 );         
4000a368:	f8 16 20 0a 	lduh  [ %i0 + 0xa ], %i4                       
  block_count = (information->maximum - index_base) /                 
4000a36c:	f6 16 20 14 	lduh  [ %i0 + 0x14 ], %i3                      
4000a370:	d0 16 20 10 	lduh  [ %i0 + 0x10 ], %o0                      
4000a374:	92 10 00 1b 	mov  %i3, %o1                                  
4000a378:	40 00 3d bf 	call  40019a74 <.udiv>                         
4000a37c:	90 22 00 1c 	sub  %o0, %i4, %o0                             
                 information->allocation_size;                        
                                                                      
  for ( block = 0; block < block_count; block++ ) {                   
4000a380:	80 a2 20 00 	cmp  %o0, 0                                    
4000a384:	02 80 00 36 	be  4000a45c <_Objects_Shrink_information+0xf8><== NEVER TAKEN
4000a388:	01 00 00 00 	nop                                            
    if ( information->inactive_per_block[ block ] ==                  
4000a38c:	c8 06 20 30 	ld  [ %i0 + 0x30 ], %g4                        
4000a390:	c2 01 00 00 	ld  [ %g4 ], %g1                               
4000a394:	80 a6 c0 01 	cmp  %i3, %g1                                  
4000a398:	02 80 00 0f 	be  4000a3d4 <_Objects_Shrink_information+0x70><== NEVER TAKEN
4000a39c:	82 10 20 00 	clr  %g1                                       
4000a3a0:	10 80 00 07 	b  4000a3bc <_Objects_Shrink_information+0x58> 
4000a3a4:	ba 10 20 04 	mov  4, %i5                                    
4000a3a8:	c4 01 00 1d 	ld  [ %g4 + %i5 ], %g2                         
4000a3ac:	80 a6 c0 02 	cmp  %i3, %g2                                  
4000a3b0:	02 80 00 0a 	be  4000a3d8 <_Objects_Shrink_information+0x74>
4000a3b4:	86 07 60 04 	add  %i5, 4, %g3                               
4000a3b8:	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++ ) {                   
4000a3bc:	82 00 60 01 	inc  %g1                                       
4000a3c0:	80 a0 40 08 	cmp  %g1, %o0                                  
4000a3c4:	12 bf ff f9 	bne  4000a3a8 <_Objects_Shrink_information+0x44>
4000a3c8:	b8 07 00 1b 	add  %i4, %i3, %i4                             
4000a3cc:	81 c7 e0 08 	ret                                            
4000a3d0:	81 e8 00 00 	restore                                        
    if ( information->inactive_per_block[ block ] ==                  
4000a3d4:	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 );                
4000a3d8:	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;                              
4000a3dc:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000a3e0:	10 80 00 05 	b  4000a3f4 <_Objects_Shrink_information+0x90> 
4000a3e4:	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 );                                          
4000a3e8:	90 96 e0 00 	orcc  %i3, 0, %o0                              
4000a3ec:	22 80 00 12 	be,a   4000a434 <_Objects_Shrink_information+0xd0>
4000a3f0:	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 );                
4000a3f4:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
4000a3f8:	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) &&                                 
4000a3fc:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000a400:	0a bf ff fa 	bcs  4000a3e8 <_Objects_Shrink_information+0x84>
4000a404:	f6 02 00 00 	ld  [ %o0 ], %i3                               
             (index < (index_base + information->allocation_size))) { 
4000a408:	c4 16 20 14 	lduh  [ %i0 + 0x14 ], %g2                      
4000a40c:	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) &&                                 
4000a410:	80 a0 40 02 	cmp  %g1, %g2                                  
4000a414:	3a bf ff f6 	bcc,a   4000a3ec <_Objects_Shrink_information+0x88>
4000a418:	90 96 e0 00 	orcc  %i3, 0, %o0                              
             (index < (index_base + information->allocation_size))) { 
           _Chain_Extract( &extract_me->Node );                       
4000a41c:	40 00 10 5f 	call  4000e598 <_Chain_Extract>                
4000a420:	01 00 00 00 	nop                                            
         }                                                            
       }                                                              
       while ( the_object );                                          
4000a424:	90 96 e0 00 	orcc  %i3, 0, %o0                              
4000a428:	32 bf ff f4 	bne,a   4000a3f8 <_Objects_Shrink_information+0x94><== ALWAYS TAKEN
4000a42c:	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 ] );         
4000a430:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        <== NOT EXECUTED
4000a434:	40 00 07 7e 	call  4000c22c <_Workspace_Free>               
4000a438:	d0 00 40 1d 	ld  [ %g1 + %i5 ], %o0                         
      information->object_blocks[ block ] = NULL;                     
4000a43c:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
      information->inactive_per_block[ block ] = 0;                   
                                                                      
      information->inactive -= information->allocation_size;          
4000a440:	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;                     
4000a444:	c0 20 40 1d 	clr  [ %g1 + %i5 ]                             
      information->inactive_per_block[ block ] = 0;                   
4000a448:	c6 06 20 30 	ld  [ %i0 + 0x30 ], %g3                        
                                                                      
      information->inactive -= information->allocation_size;          
4000a44c:	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;                   
4000a450:	c0 20 c0 1d 	clr  [ %g3 + %i5 ]                             
                                                                      
      information->inactive -= information->allocation_size;          
4000a454:	82 20 80 01 	sub  %g2, %g1, %g1                             
4000a458:	c2 36 20 2c 	sth  %g1, [ %i0 + 0x2c ]                       
                                                                      
      return;                                                         
4000a45c:	81 c7 e0 08 	ret                                            
4000a460:	81 e8 00 00 	restore                                        
                                                                      

40010114 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) {
40010114:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
40010118:	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 ];     
4001011c:	35 00 00 3f 	sethi  %hi(0xfc00), %i2                        
40010120:	b3 30 60 18 	srl  %g1, 0x18, %i1                            
40010124:	b4 16 a3 ff 	or  %i2, 0x3ff, %i2                            
40010128:	b2 0e 60 07 	and  %i1, 7, %i1                               
4001012c:	b4 08 40 1a 	and  %g1, %i2, %i2                             
40010130:	b2 06 60 04 	add  %i1, 4, %i1                               
40010134:	3b 10 00 81 	sethi  %hi(0x40020400), %i5                    
40010138:	b5 2e a0 02 	sll  %i2, 2, %i2                               
4001013c:	ba 17 62 8c 	or  %i5, 0x28c, %i5                            
40010140:	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 ) {                      
40010144:	c2 17 60 10 	lduh  [ %i5 + 0x10 ], %g1                      
40010148:	80 a0 60 00 	cmp  %g1, 0                                    
4001014c:	02 80 00 21 	be  400101d0 <_POSIX_Keys_Run_destructors+0xbc>
40010150:	b8 10 20 01 	mov  1, %i4                                    
40010154:	86 10 20 01 	mov  1, %g3                                    
40010158:	b6 10 00 01 	mov  %g1, %i3                                  
      POSIX_Keys_Control *key = (POSIX_Keys_Control *)                
4001015c:	c8 07 60 1c 	ld  [ %i5 + 0x1c ], %g4                        
        _POSIX_Keys_Information.local_table [ index ];                
40010160:	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 *)                
40010164:	85 30 a0 0e 	srl  %g2, 0xe, %g2                             
40010168:	c4 01 00 02 	ld  [ %g4 + %g2 ], %g2                         
        _POSIX_Keys_Information.local_table [ index ];                
                                                                      
      if ( key != NULL && key->destructor != NULL ) {                 
4001016c:	80 a0 a0 00 	cmp  %g2, 0                                    
40010170:	02 80 00 10 	be  400101b0 <_POSIX_Keys_Run_destructors+0x9c>
40010174:	82 00 80 19 	add  %g2, %i1, %g1                             
40010178:	c8 00 a0 10 	ld  [ %g2 + 0x10 ], %g4                        
4001017c:	80 a1 20 00 	cmp  %g4, 0                                    
40010180:	22 80 00 0d 	be,a   400101b4 <_POSIX_Keys_Run_destructors+0xa0>
40010184:	b8 07 20 01 	inc  %i4                                       
        void *value = key->Values [ thread_api ][ thread_index ];     
40010188:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
4001018c:	d0 01 00 1a 	ld  [ %g4 + %i2 ], %o0                         
                                                                      
        if ( value != NULL ) {                                        
40010190:	80 a2 20 00 	cmp  %o0, 0                                    
40010194:	22 80 00 08 	be,a   400101b4 <_POSIX_Keys_Run_destructors+0xa0><== ALWAYS TAKEN
40010198:	b8 07 20 01 	inc  %i4                                       
          key->Values [ thread_api ][ thread_index ] = NULL;          
4001019c:	c0 21 00 1a 	clr  [ %g4 + %i2 ]                             <== NOT EXECUTED
          (*key->destructor)( value );                                
400101a0:	c2 00 a0 10 	ld  [ %g2 + 0x10 ], %g1                        <== NOT EXECUTED
400101a4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400101a8:	01 00 00 00 	nop                                            <== NOT EXECUTED
          done = false;                                               
400101ac:	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 ) {                      
400101b0:	b8 07 20 01 	inc  %i4                                       
400101b4:	85 2f 20 10 	sll  %i4, 0x10, %g2                            
400101b8:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
400101bc:	80 a6 c0 02 	cmp  %i3, %g2                                  
400101c0:	1a bf ff e7 	bcc  4001015c <_POSIX_Keys_Run_destructors+0x48>
400101c4:	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 ) {                                                   
400101c8:	22 bf ff e0 	be,a   40010148 <_POSIX_Keys_Run_destructors+0x34><== NEVER TAKEN
400101cc:	c2 17 60 10 	lduh  [ %i5 + 0x10 ], %g1                      <== NOT EXECUTED
400101d0:	81 c7 e0 08 	ret                                            
400101d4:	81 e8 00 00 	restore                                        
                                                                      

4000d428 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) {
4000d428:	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(             
4000d42c:	11 10 00 a8 	sethi  %hi(0x4002a000), %o0                    
4000d430:	92 10 00 18 	mov  %i0, %o1                                  
4000d434:	90 12 23 b0 	or  %o0, 0x3b0, %o0                            
4000d438:	40 00 0d 8d 	call  40010a6c <_Objects_Get>                  
4000d43c:	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 ) {                                               
4000d440:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000d444:	80 a0 60 00 	cmp  %g1, 0                                    
4000d448:	22 80 00 08 	be,a   4000d468 <_POSIX_Message_queue_Receive_support+0x40>
4000d44c:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EBADF );                      
4000d450:	40 00 29 59 	call  400179b4 <__errno>                       
4000d454:	b0 10 3f ff 	mov  -1, %i0                                   
4000d458:	82 10 20 09 	mov  9, %g1                                    
4000d45c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
4000d460:	81 c7 e0 08 	ret                                            
4000d464:	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 ) {             
4000d468:	84 08 60 03 	and  %g1, 3, %g2                               
4000d46c:	80 a0 a0 01 	cmp  %g2, 1                                    
4000d470:	02 80 00 39 	be  4000d554 <_POSIX_Message_queue_Receive_support+0x12c>
4000d474:	01 00 00 00 	nop                                            
        _Thread_Enable_dispatch();                                    
        rtems_set_errno_and_return_minus_one( EBADF );                
      }                                                               
                                                                      
      the_mq = the_mq_fd->Queue;                                      
4000d478:	d0 02 20 10 	ld  [ %o0 + 0x10 ], %o0                        
                                                                      
      if ( msg_len < the_mq->Message_queue.maximum_message_size ) {   
4000d47c:	c4 02 20 68 	ld  [ %o0 + 0x68 ], %g2                        
4000d480:	80 a0 80 1a 	cmp  %g2, %i2                                  
4000d484:	18 80 00 23 	bgu  4000d510 <_POSIX_Message_queue_Receive_support+0xe8>
4000d488:	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;                                                
4000d48c:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
                                                                      
      /*                                                              
       *  A timed receive with a bad time will do a poll regardless.  
       */                                                             
      if ( wait )                                                     
4000d490:	80 a7 20 00 	cmp  %i4, 0                                    
4000d494:	12 80 00 1b 	bne  4000d500 <_POSIX_Message_queue_Receive_support+0xd8>
4000d498:	98 10 20 00 	clr  %o4                                       
        do_wait = wait;                                               
                                                                      
      /*                                                              
       *  Now perform the actual message receive                      
       */                                                             
      _CORE_message_queue_Seize(                                      
4000d49c:	9a 10 00 1d 	mov  %i5, %o5                                  
4000d4a0:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
4000d4a4:	92 10 00 18 	mov  %i0, %o1                                  
4000d4a8:	94 10 00 19 	mov  %i1, %o2                                  
4000d4ac:	96 07 bf fc 	add  %fp, -4, %o3                              
4000d4b0:	40 00 08 f2 	call  4000f878 <_CORE_message_queue_Seize>     
4000d4b4:	98 0b 20 01 	and  %o4, 1, %o4                               
        &length_out,                                                  
        do_wait,                                                      
        timeout                                                       
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
4000d4b8:	40 00 11 48 	call  400119d8 <_Thread_Enable_dispatch>       
4000d4bc:	3b 10 00 a9 	sethi  %hi(0x4002a400), %i5                    
      if (msg_prio) {                                                 
4000d4c0:	80 a6 e0 00 	cmp  %i3, 0                                    
        *msg_prio = _POSIX_Message_queue_Priority_from_core(          
             _Thread_Executing->Wait.count                            
4000d4c4:	ba 17 60 30 	or  %i5, 0x30, %i5                             
        do_wait,                                                      
        timeout                                                       
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if (msg_prio) {                                                 
4000d4c8:	02 80 00 07 	be  4000d4e4 <_POSIX_Message_queue_Receive_support+0xbc><== NEVER TAKEN
4000d4cc:	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);     
4000d4d0:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3                        
4000d4d4:	85 38 e0 1f 	sra  %g3, 0x1f, %g2                            
4000d4d8:	86 18 80 03 	xor  %g2, %g3, %g3                             
4000d4dc:	84 20 c0 02 	sub  %g3, %g2, %g2                             
        *msg_prio = _POSIX_Message_queue_Priority_from_core(          
4000d4e0:	c4 26 c0 00 	st  %g2, [ %i3 ]                               
             _Thread_Executing->Wait.count                            
          );                                                          
      }                                                               
                                                                      
      if ( !_Thread_Executing->Wait.return_code )                     
4000d4e4:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
4000d4e8:	80 a0 60 00 	cmp  %g1, 0                                    
4000d4ec:	12 80 00 11 	bne  4000d530 <_POSIX_Message_queue_Receive_support+0x108>
4000d4f0:	01 00 00 00 	nop                                            
        return length_out;                                            
4000d4f4:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
4000d4f8:	81 c7 e0 08 	ret                                            
4000d4fc:	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;     
4000d500:	99 30 60 0e 	srl  %g1, 0xe, %o4                             
4000d504:	98 1b 20 01 	xor  %o4, 1, %o4                               
4000d508:	10 bf ff e5 	b  4000d49c <_POSIX_Message_queue_Receive_support+0x74>
4000d50c:	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();                                    
4000d510:	40 00 11 32 	call  400119d8 <_Thread_Enable_dispatch>       
4000d514:	b0 10 3f ff 	mov  -1, %i0                                   
        rtems_set_errno_and_return_minus_one( EMSGSIZE );             
4000d518:	40 00 29 27 	call  400179b4 <__errno>                       
4000d51c:	01 00 00 00 	nop                                            
4000d520:	82 10 20 7a 	mov  0x7a, %g1	! 7a <PROM_START+0x7a>          
4000d524:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000d528:	81 c7 e0 08 	ret                                            
4000d52c:	81 e8 00 00 	restore                                        
      }                                                               
                                                                      
      if ( !_Thread_Executing->Wait.return_code )                     
        return length_out;                                            
                                                                      
      rtems_set_errno_and_return_minus_one(                           
4000d530:	40 00 29 21 	call  400179b4 <__errno>                       
4000d534:	b0 10 3f ff 	mov  -1, %i0                                   
4000d538:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000d53c:	b8 10 00 08 	mov  %o0, %i4                                  
4000d540:	40 00 00 a2 	call  4000d7c8 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
4000d544:	d0 00 60 34 	ld  [ %g1 + 0x34 ], %o0                        
4000d548:	d0 27 00 00 	st  %o0, [ %i4 ]                               
4000d54c:	81 c7 e0 08 	ret                                            
4000d550:	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();                                    
4000d554:	40 00 11 21 	call  400119d8 <_Thread_Enable_dispatch>       
4000d558:	b0 10 3f ff 	mov  -1, %i0                                   
        rtems_set_errno_and_return_minus_one( EBADF );                
4000d55c:	40 00 29 16 	call  400179b4 <__errno>                       
4000d560:	01 00 00 00 	nop                                            
4000d564:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
4000d568:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000d56c:	81 c7 e0 08 	ret                                            
4000d570:	81 e8 00 00 	restore                                        
                                                                      

4000ffb0 <_POSIX_Semaphore_Create_support>: size_t name_len, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) {
4000ffb0:	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)                                                   
4000ffb4:	80 a6 a0 00 	cmp  %i2, 0                                    
4000ffb8:	12 80 00 2f 	bne  40010074 <_POSIX_Semaphore_Create_support+0xc4>
4000ffbc:	03 10 00 93 	sethi  %hi(0x40024c00), %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;                  
4000ffc0:	c4 00 60 b0 	ld  [ %g1 + 0xb0 ], %g2	! 40024cb0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
4000ffc4:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
4000ffc8:	c4 20 60 b0 	st  %g2, [ %g1 + 0xb0 ]                        
 *  _POSIX_Semaphore_Allocate                                         
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{                                                                     
  return (POSIX_Semaphore_Control *)                                  
4000ffcc:	35 10 00 93 	sethi  %hi(0x40024c00), %i2                    
4000ffd0:	7f ff ee 18 	call  4000b830 <_Objects_Allocate>             
4000ffd4:	90 16 a3 74 	or  %i2, 0x374, %o0	! 40024f74 <_POSIX_Semaphore_Information>
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_semaphore = _POSIX_Semaphore_Allocate();                        
  if ( !the_semaphore ) {                                             
4000ffd8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000ffdc:	02 80 00 2c 	be  4001008c <_POSIX_Semaphore_Create_support+0xdc>
4000ffe0:	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 ) {                                           
4000ffe4:	02 80 00 1e 	be  4001005c <_POSIX_Semaphore_Create_support+0xac>
4000ffe8:	92 10 00 19 	mov  %i1, %o1                                  
    name = _Workspace_String_duplicate( name_arg, name_len );         
4000ffec:	40 00 04 10 	call  4001102c <_Workspace_String_duplicate>   
4000fff0:	90 10 00 18 	mov  %i0, %o0                                  
    if ( !name ) {                                                    
4000fff4:	b2 92 20 00 	orcc  %o0, 0, %i1                              
4000fff8:	02 80 00 2d 	be  400100ac <_POSIX_Semaphore_Create_support+0xfc><== NEVER TAKEN
4000fffc:	82 10 20 01 	mov  1, %g1                                    
  }                                                                   
                                                                      
  the_semaphore->process_shared  = pshared;                           
                                                                      
  if ( name ) {                                                       
    the_semaphore->named = true;                                      
40010000:	84 10 20 01 	mov  1, %g2                                    
    }                                                                 
  } else {                                                            
    name = NULL;                                                      
  }                                                                   
                                                                      
  the_semaphore->process_shared  = pshared;                           
40010004:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
                                                                      
  if ( name ) {                                                       
    the_semaphore->named = true;                                      
40010008:	c4 2f 60 14 	stb  %g2, [ %i5 + 0x14 ]                       
    the_semaphore->open_count = 1;                                    
4001000c:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
    the_semaphore->linked = true;                                     
40010010:	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;                           
40010014:	82 10 3f ff 	mov  -1, %g1                                   
                                                                      
  _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
40010018:	90 07 60 1c 	add  %i5, 0x1c, %o0                            
4001001c:	92 07 60 5c 	add  %i5, 0x5c, %o1                            
40010020:	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;                           
40010024:	c2 27 60 5c 	st  %g1, [ %i5 + 0x5c ]                        
                                                                      
  _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
40010028:	7f ff ec 5f 	call  4000b1a4 <_CORE_semaphore_Initialize>    
4001002c:	c0 27 60 60 	clr  [ %i5 + 0x60 ]                            
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40010030:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40010034:	b4 16 a3 74 	or  %i2, 0x374, %i2                            
40010038:	c4 06 a0 1c 	ld  [ %i2 + 0x1c ], %g2                        
4001003c:	83 28 60 02 	sll  %g1, 2, %g1                               
40010040:	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;                                   
40010044:	f2 27 60 0c 	st  %i1, [ %i5 + 0xc ]                         
    &_POSIX_Semaphore_Information,                                    
    &the_semaphore->Object,                                           
    name                                                              
  );                                                                  
                                                                      
  *the_sem = the_semaphore;                                           
40010048:	fa 27 00 00 	st  %i5, [ %i4 ]                               
                                                                      
  _Thread_Enable_dispatch();                                          
4001004c:	7f ff f3 45 	call  4000cd60 <_Thread_Enable_dispatch>       
40010050:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
40010054:	81 c7 e0 08 	ret                                            
40010058:	81 e8 00 00 	restore                                        
    }                                                                 
  } else {                                                            
    name = NULL;                                                      
  }                                                                   
                                                                      
  the_semaphore->process_shared  = pshared;                           
4001005c:	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;                                     
40010060:	c0 2f 60 14 	clrb  [ %i5 + 0x14 ]                           
    the_semaphore->open_count = 0;                                    
40010064:	c0 27 60 18 	clr  [ %i5 + 0x18 ]                            
    the_semaphore->linked = false;                                    
40010068:	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;                                                      
4001006c:	10 bf ff ea 	b  40010014 <_POSIX_Semaphore_Create_support+0x64>
40010070:	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 );                   
40010074:	40 00 09 fa 	call  4001285c <__errno>                       
40010078:	b0 10 3f ff 	mov  -1, %i0                                   
4001007c:	82 10 20 58 	mov  0x58, %g1                                 
40010080:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40010084:	81 c7 e0 08 	ret                                            
40010088:	81 e8 00 00 	restore                                        
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_semaphore = _POSIX_Semaphore_Allocate();                        
  if ( !the_semaphore ) {                                             
    _Thread_Enable_dispatch();                                        
4001008c:	7f ff f3 35 	call  4000cd60 <_Thread_Enable_dispatch>       
40010090:	b0 10 3f ff 	mov  -1, %i0                                   
    rtems_set_errno_and_return_minus_one( ENOSPC );                   
40010094:	40 00 09 f2 	call  4001285c <__errno>                       
40010098:	01 00 00 00 	nop                                            
4001009c:	82 10 20 1c 	mov  0x1c, %g1	! 1c <PROM_START+0x1c>          
400100a0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400100a4:	81 c7 e0 08 	ret                                            
400100a8:	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 );
400100ac:	90 16 a3 74 	or  %i2, 0x374, %o0                            <== NOT EXECUTED
400100b0:	7f ff ee d8 	call  4000bc10 <_Objects_Free>                 <== NOT EXECUTED
400100b4:	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();                                      
400100b8:	7f ff f3 2a 	call  4000cd60 <_Thread_Enable_dispatch>       <== NOT EXECUTED
400100bc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
      rtems_set_errno_and_return_minus_one( ENOMEM );                 
400100c0:	40 00 09 e7 	call  4001285c <__errno>                       <== NOT EXECUTED
400100c4:	01 00 00 00 	nop                                            <== NOT EXECUTED
400100c8:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
400100cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400100d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400100d4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000d664 <_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 ];
4000d664:	c2 02 21 50 	ld  [ %o0 + 0x150 ], %g1                       
                                                                      
  if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
4000d668:	c4 00 60 d8 	ld  [ %g1 + 0xd8 ], %g2                        
4000d66c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000d670:	12 80 00 06 	bne  4000d688 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24><== NEVER TAKEN
4000d674:	01 00 00 00 	nop                                            
4000d678:	c4 00 60 dc 	ld  [ %g1 + 0xdc ], %g2                        
4000d67c:	80 a0 a0 01 	cmp  %g2, 1                                    
4000d680:	22 80 00 05 	be,a   4000d694 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x30>
4000d684:	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();                                        
4000d688:	82 13 c0 00 	mov  %o7, %g1                                  
4000d68c:	7f ff f6 0c 	call  4000aebc <_Thread_Enable_dispatch>       
4000d690:	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 &&
4000d694:	80 a0 60 00 	cmp  %g1, 0                                    
4000d698:	02 bf ff fc 	be  4000d688 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x24>
4000d69c:	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;                  
4000d6a0:	03 10 00 64 	sethi  %hi(0x40019000), %g1                    
4000d6a4:	c4 00 60 e0 	ld  [ %g1 + 0xe0 ], %g2	! 400190e0 <_Thread_Dispatch_disable_level>
       thread_support->cancelation_requested ) {                      
    _Thread_Unnest_dispatch();                                        
    _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );               
4000d6a8:	92 10 3f ff 	mov  -1, %o1                                   
                                                                      
    --level;                                                          
4000d6ac:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
4000d6b0:	c4 20 60 e0 	st  %g2, [ %g1 + 0xe0 ]                        
4000d6b4:	82 13 c0 00 	mov  %o7, %g1                                  
4000d6b8:	40 00 01 d9 	call  4000de1c <_POSIX_Thread_Exit>            
4000d6bc:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

4000eb60 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) {
4000eb60:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )           
4000eb64:	7f ff ff f2 	call  4000eb2c <_POSIX_Priority_Is_valid>      
4000eb68:	d0 06 40 00 	ld  [ %i1 ], %o0                               
4000eb6c:	80 8a 20 ff 	btst  0xff, %o0                                
4000eb70:	32 80 00 04 	bne,a   4000eb80 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
4000eb74:	c0 26 80 00 	clr  [ %i2 ]                                   
    return EINVAL;                                                    
4000eb78:	81 c7 e0 08 	ret                                            
4000eb7c:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
                                                                      
  *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;               
  *budget_callout = NULL;                                             
                                                                      
  if ( policy == SCHED_OTHER ) {                                      
4000eb80:	80 a6 20 00 	cmp  %i0, 0                                    
4000eb84:	02 80 00 2c 	be  4000ec34 <_POSIX_Thread_Translate_sched_param+0xd4>
4000eb88:	c0 26 c0 00 	clr  [ %i3 ]                                   
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;  
    return 0;                                                         
  }                                                                   
                                                                      
  if ( policy == SCHED_FIFO ) {                                       
4000eb8c:	80 a6 20 01 	cmp  %i0, 1                                    
4000eb90:	02 80 00 2d 	be  4000ec44 <_POSIX_Thread_Translate_sched_param+0xe4>
4000eb94:	80 a6 20 02 	cmp  %i0, 2                                    
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;             
    return 0;                                                         
  }                                                                   
                                                                      
  if ( policy == SCHED_RR ) {                                         
4000eb98:	02 80 00 2d 	be  4000ec4c <_POSIX_Thread_Translate_sched_param+0xec>
4000eb9c:	80 a6 20 04 	cmp  %i0, 4                                    
    *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
    return 0;                                                         
  }                                                                   
                                                                      
  if ( policy == SCHED_SPORADIC ) {                                   
4000eba0:	12 bf ff f6 	bne  4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000eba4:	01 00 00 00 	nop                                            
    if ( (param->sched_ss_repl_period.tv_sec == 0) &&                 
4000eba8:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4000ebac:	80 a0 60 00 	cmp  %g1, 0                                    
4000ebb0:	32 80 00 07 	bne,a   4000ebcc <_POSIX_Thread_Translate_sched_param+0x6c>
4000ebb4:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000ebb8:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
4000ebbc:	80 a0 60 00 	cmp  %g1, 0                                    
4000ebc0:	02 bf ff ee 	be  4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000ebc4:	01 00 00 00 	nop                                            
         (param->sched_ss_repl_period.tv_nsec == 0) )                 
      return EINVAL;                                                  
                                                                      
    if ( (param->sched_ss_init_budget.tv_sec == 0) &&                 
4000ebc8:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000ebcc:	80 a0 60 00 	cmp  %g1, 0                                    
4000ebd0:	12 80 00 06 	bne  4000ebe8 <_POSIX_Thread_Translate_sched_param+0x88>
4000ebd4:	01 00 00 00 	nop                                            
4000ebd8:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        
4000ebdc:	80 a0 60 00 	cmp  %g1, 0                                    
4000ebe0:	02 bf ff e6 	be  4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000ebe4:	01 00 00 00 	nop                                            
         (param->sched_ss_init_budget.tv_nsec == 0) )                 
      return EINVAL;                                                  
                                                                      
    if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <         
4000ebe8:	7f ff f7 15 	call  4000c83c <_Timespec_To_ticks>            
4000ebec:	90 06 60 08 	add  %i1, 8, %o0                               
4000ebf0:	ba 10 00 08 	mov  %o0, %i5                                  
	 _Timespec_To_ticks( ¶m->sched_ss_init_budget ) )                
4000ebf4:	7f ff f7 12 	call  4000c83c <_Timespec_To_ticks>            
4000ebf8:	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 ) <         
4000ebfc:	80 a7 40 08 	cmp  %i5, %o0                                  
4000ec00:	0a bf ff de 	bcs  4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000ec04:	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 ) )  
4000ec08:	7f ff ff c9 	call  4000eb2c <_POSIX_Priority_Is_valid>      
4000ec0c:	d0 06 60 04 	ld  [ %i1 + 4 ], %o0                           
4000ec10:	80 8a 20 ff 	btst  0xff, %o0                                
4000ec14:	02 bf ff d9 	be  4000eb78 <_POSIX_Thread_Translate_sched_param+0x18>
4000ec18:	82 10 20 03 	mov  3, %g1                                    
      return EINVAL;                                                  
                                                                      
    *budget_algorithm  = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;         
4000ec1c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    *budget_callout = _POSIX_Threads_Sporadic_budget_callout;         
4000ec20:	03 10 00 22 	sethi  %hi(0x40008800), %g1                    
4000ec24:	82 10 60 ac 	or  %g1, 0xac, %g1	! 400088ac <_POSIX_Threads_Sporadic_budget_callout>
4000ec28:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    return 0;                                                         
4000ec2c:	81 c7 e0 08 	ret                                            
4000ec30:	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;  
4000ec34:	82 10 20 01 	mov  1, %g1                                    
4000ec38:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    return 0;                                                         
4000ec3c:	81 c7 e0 08 	ret                                            
4000ec40:	81 e8 00 00 	restore                                        
    *budget_callout = _POSIX_Threads_Sporadic_budget_callout;         
    return 0;                                                         
  }                                                                   
                                                                      
  return EINVAL;                                                      
}                                                                     
4000ec44:	81 c7 e0 08 	ret                                            
4000ec48:	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;
4000ec4c:	f0 26 80 00 	st  %i0, [ %i2 ]                               
    return 0;                                                         
4000ec50:	81 c7 e0 08 	ret                                            
4000ec54:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000dd9c <_POSIX_Threads_Delete_extension>: */ static void _POSIX_Threads_Delete_extension( Thread_Control *executing __attribute__((unused)), Thread_Control *deleted ) {
4000dd9c:	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 ];                  
4000dda0:	f0 06 61 50 	ld  [ %i1 + 0x150 ], %i0                       
                                                                      
  /*                                                                  
   *  Run the POSIX cancellation handlers                             
   */                                                                 
  _POSIX_Threads_cancel_run( deleted );                               
4000dda4:	40 00 08 c0 	call  400100a4 <_POSIX_Threads_cancel_run>     
4000dda8:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  /*                                                                  
   *  Run all the key destructors                                     
   */                                                                 
  _POSIX_Keys_Run_destructors( deleted );                             
4000ddac:	90 10 00 19 	mov  %i1, %o0                                  
4000ddb0:	40 00 08 d9 	call  40010114 <_POSIX_Keys_Run_destructors>   
4000ddb4:	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 )) )   
4000ddb8:	10 80 00 03 	b  4000ddc4 <_POSIX_Threads_Delete_extension+0x28>
4000ddbc:	f8 06 60 28 	ld  [ %i1 + 0x28 ], %i4                        
      *(void **)the_thread->Wait.return_argument = value_ptr;         
4000ddc0:	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 )) )   
4000ddc4:	7f ff f5 9a 	call  4000b42c <_Thread_queue_Dequeue>         
4000ddc8:	90 10 00 1d 	mov  %i5, %o0                                  
4000ddcc:	80 a2 20 00 	cmp  %o0, 0                                    
4000ddd0:	32 bf ff fc 	bne,a   4000ddc0 <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
4000ddd4:	c2 02 20 28 	ld  [ %o0 + 0x28 ], %g1                        <== NOT EXECUTED
      *(void **)the_thread->Wait.return_argument = value_ptr;         
                                                                      
  if ( api->schedpolicy == SCHED_SPORADIC )                           
4000ddd8:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
4000dddc:	80 a0 60 04 	cmp  %g1, 4                                    
4000dde0:	02 80 00 05 	be  4000ddf4 <_POSIX_Threads_Delete_extension+0x58>
4000dde4:	01 00 00 00 	nop                                            
    (void) _Watchdog_Remove( &api->Sporadic_timer );                  
                                                                      
  deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;                 
4000dde8:	c0 26 61 50 	clr  [ %i1 + 0x150 ]                           
                                                                      
  _Workspace_Free( api );                                             
4000ddec:	7f ff f9 10 	call  4000c22c <_Workspace_Free>               
4000ddf0:	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 );                  
4000ddf4:	7f ff f8 50 	call  4000bf34 <_Watchdog_Remove>              
4000ddf8:	90 06 20 a8 	add  %i0, 0xa8, %o0                            
                                                                      
  deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;                 
4000ddfc:	c0 26 61 50 	clr  [ %i1 + 0x150 ]                           
                                                                      
  _Workspace_Free( api );                                             
4000de00:	7f ff f9 0b 	call  4000c22c <_Workspace_Free>               
4000de04:	81 e8 00 00 	restore                                        
                                                                      

400085c0 <_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) {
400085c0:	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;
400085c4:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
400085c8:	82 10 60 04 	or  %g1, 4, %g1	! 40020004 <Configuration_POSIX_API>
  maximum      = Configuration_POSIX_API.number_of_initialization_threads;
400085cc:	f6 00 60 30 	ld  [ %g1 + 0x30 ], %i3                        
                                                                      
  if ( !user_threads || maximum == 0 )                                
400085d0:	80 a6 e0 00 	cmp  %i3, 0                                    
400085d4:	02 80 00 18 	be  40008634 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
400085d8:	fa 00 60 34 	ld  [ %g1 + 0x34 ], %i5                        
400085dc:	80 a7 60 00 	cmp  %i5, 0                                    
400085e0:	02 80 00 15 	be  40008634 <_POSIX_Threads_Initialize_user_threads_body+0x74><== NEVER TAKEN
400085e4:	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 );                                
400085e8:	40 00 19 9c 	call  4000ec58 <pthread_attr_init>             
400085ec:	90 07 bf c0 	add  %fp, -64, %o0                             
    (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
400085f0:	92 10 20 02 	mov  2, %o1                                    
400085f4:	40 00 19 a5 	call  4000ec88 <pthread_attr_setinheritsched>  
400085f8:	90 07 bf c0 	add  %fp, -64, %o0                             
    (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
400085fc:	d2 07 60 04 	ld  [ %i5 + 4 ], %o1                           
40008600:	40 00 19 b2 	call  4000ecc8 <pthread_attr_setstacksize>     
40008604:	90 07 bf c0 	add  %fp, -64, %o0                             
                                                                      
    status = pthread_create(                                          
40008608:	d4 07 40 00 	ld  [ %i5 ], %o2                               
4000860c:	90 07 bf bc 	add  %fp, -68, %o0                             
40008610:	92 07 bf c0 	add  %fp, -64, %o1                             
40008614:	7f ff ff 00 	call  40008214 <pthread_create>                
40008618:	96 10 20 00 	clr  %o3                                       
      &thread_id,                                                     
      &attr,                                                          
      user_threads[ index ].thread_entry,                             
      NULL                                                            
    );                                                                
    if ( status )                                                     
4000861c:	94 92 20 00 	orcc  %o0, 0, %o2                              
40008620:	12 80 00 07 	bne  4000863c <_POSIX_Threads_Initialize_user_threads_body+0x7c>
40008624:	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++ ) {                       
40008628:	80 a7 00 1b 	cmp  %i4, %i3                                  
4000862c:	12 bf ff ef 	bne  400085e8 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
40008630:	ba 07 60 08 	add  %i5, 8, %i5                               
40008634:	81 c7 e0 08 	ret                                            
40008638:	81 e8 00 00 	restore                                        
      &attr,                                                          
      user_threads[ index ].thread_entry,                             
      NULL                                                            
    );                                                                
    if ( status )                                                     
      _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
4000863c:	90 10 20 02 	mov  2, %o0                                    
40008640:	40 00 08 79 	call  4000a824 <_Internal_error_Occurred>      
40008644:	92 10 20 01 	mov  1, %o1                                    
                                                                      

4000df28 <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) {
4000df28:	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 ];               
4000df2c:	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 );
4000df30:	40 00 03 bb 	call  4000ee1c <_Timespec_To_ticks>            
4000df34:	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);
4000df38:	c4 07 60 88 	ld  [ %i5 + 0x88 ], %g2                        
4000df3c:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
4000df40:	d2 08 60 dc 	ldub  [ %g1 + 0xdc ], %o1	! 4001f4dc <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 ) {                            
4000df44:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
4000df48:	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;                                
4000df4c:	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 ) {                            
4000df50:	80 a0 60 00 	cmp  %g1, 0                                    
4000df54:	12 80 00 06 	bne  4000df6c <_POSIX_Threads_Sporadic_budget_TSR+0x44><== NEVER TAKEN
4000df58:	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 ) {              
4000df5c:	c2 06 60 14 	ld  [ %i1 + 0x14 ], %g1                        
4000df60:	80 a0 40 09 	cmp  %g1, %o1                                  
4000df64:	18 80 00 09 	bgu  4000df88 <_POSIX_Threads_Sporadic_budget_TSR+0x60>
4000df68:	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 );
4000df6c:	90 07 60 90 	add  %i5, 0x90, %o0                            
4000df70:	40 00 03 ab 	call  4000ee1c <_Timespec_To_ticks>            
4000df74:	31 10 00 80 	sethi  %hi(0x40020000), %i0                    
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000df78:	b2 07 60 a8 	add  %i5, 0xa8, %i1                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
4000df7c:	d0 27 60 b4 	st  %o0, [ %i5 + 0xb4 ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000df80:	7f ff f7 8e 	call  4000bdb8 <_Watchdog_Insert>              
4000df84:	91 ee 23 48 	restore  %i0, 0x348, %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 );      
4000df88:	7f ff f3 16 	call  4000abe0 <_Thread_Change_priority>       
4000df8c:	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 );
4000df90:	90 07 60 90 	add  %i5, 0x90, %o0                            
4000df94:	40 00 03 a2 	call  4000ee1c <_Timespec_To_ticks>            
4000df98:	31 10 00 80 	sethi  %hi(0x40020000), %i0                    
4000df9c:	b2 07 60 a8 	add  %i5, 0xa8, %i1                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
4000dfa0:	d0 27 60 b4 	st  %o0, [ %i5 + 0xb4 ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000dfa4:	7f ff f7 85 	call  4000bdb8 <_Watchdog_Insert>              
4000dfa8:	91 ee 23 48 	restore  %i0, 0x348, %o0                       
                                                                      

4000dfac <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ];
4000dfac:	c4 02 21 50 	ld  [ %o0 + 0x150 ], %g2                       
4000dfb0:	c6 00 a0 8c 	ld  [ %g2 + 0x8c ], %g3                        
4000dfb4:	05 10 00 7d 	sethi  %hi(0x4001f400), %g2                    
4000dfb8:	d2 08 a0 dc 	ldub  [ %g2 + 0xdc ], %o1	! 4001f4dc <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 ) {                            
4000dfbc:	c4 02 20 1c 	ld  [ %o0 + 0x1c ], %g2                        
4000dfc0:	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 */
4000dfc4:	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;                           
4000dfc8:	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 ) {                            
4000dfcc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000dfd0:	12 80 00 06 	bne  4000dfe8 <_POSIX_Threads_Sporadic_budget_callout+0x3c><== NEVER TAKEN
4000dfd4:	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 ) {              
4000dfd8:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
4000dfdc:	80 a0 40 09 	cmp  %g1, %o1                                  
4000dfe0:	0a 80 00 04 	bcs  4000dff0 <_POSIX_Threads_Sporadic_budget_callout+0x44><== ALWAYS TAKEN
4000dfe4:	94 10 20 01 	mov  1, %o2                                    
4000dfe8:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4000dfec:	01 00 00 00 	nop                                            <== NOT EXECUTED
      _Thread_Change_priority( the_thread, new_priority, true );      
4000dff0:	82 13 c0 00 	mov  %o7, %g1                                  
4000dff4:	7f ff f2 fb 	call  4000abe0 <_Thread_Change_priority>       
4000dff8:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

400100a4 <_POSIX_Threads_cancel_run>: #include <rtems/posix/threadsup.h> void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) {
400100a4:	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 ];    
400100a8:	f8 06 21 50 	ld  [ %i0 + 0x150 ], %i4                       
                                                                      
  handler_stack = &thread_support->Cancellation_Handlers;             
                                                                      
  thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;       
400100ac:	84 10 20 01 	mov  1, %g2                                    
                                                                      
  while ( !_Chain_Is_empty( handler_stack ) ) {                       
400100b0:	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 );                            
400100b4:	b6 07 20 e8 	add  %i4, 0xe8, %i3                            
400100b8:	80 a0 40 1b 	cmp  %g1, %i3                                  
400100bc:	02 80 00 14 	be  4001010c <_POSIX_Threads_cancel_run+0x68>  
400100c0:	c4 27 20 d8 	st  %g2, [ %i4 + 0xd8 ]                        
    _ISR_Disable( level );                                            
400100c4:	7f ff c9 03 	call  400024d0 <sparc_disable_interrupts>      
400100c8:	01 00 00 00 	nop                                            
      handler = (POSIX_Cancel_Handler_control *)                      
400100cc:	fa 07 20 ec 	ld  [ %i4 + 0xec ], %i5                        
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
400100d0:	c4 07 40 00 	ld  [ %i5 ], %g2                               
  previous       = the_node->previous;                                
400100d4:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
  next->previous = previous;                                          
400100d8:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
400100dc:	c4 20 40 00 	st  %g2, [ %g1 ]                               
           _Chain_Tail( handler_stack )->previous;                    
      _Chain_Extract_unprotected( &handler->Node );                   
    _ISR_Enable( level );                                             
400100e0:	7f ff c9 00 	call  400024e0 <sparc_enable_interrupts>       
400100e4:	01 00 00 00 	nop                                            
                                                                      
    (*handler->routine)( handler->arg );                              
400100e8:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
400100ec:	9f c0 40 00 	call  %g1                                      
400100f0:	d0 07 60 0c 	ld  [ %i5 + 0xc ], %o0                         
                                                                      
    _Workspace_Free( handler );                                       
400100f4:	7f ff f0 4e 	call  4000c22c <_Workspace_Free>               
400100f8:	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 ) ) {                       
400100fc:	c2 07 20 e4 	ld  [ %i4 + 0xe4 ], %g1                        
40010100:	80 a0 40 1b 	cmp  %g1, %i3                                  
40010104:	12 bf ff f0 	bne  400100c4 <_POSIX_Threads_cancel_run+0x20> <== NEVER TAKEN
40010108:	01 00 00 00 	nop                                            
4001010c:	81 c7 e0 08 	ret                                            
40010110:	81 e8 00 00 	restore                                        
                                                                      

4000834c <_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) {
4000834c:	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;                              
40008350:	c4 06 60 68 	ld  [ %i1 + 0x68 ], %g2                        
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
40008354:	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;                              
40008358:	84 00 a0 01 	inc  %g2                                       
                                                                      
  /* The timer must be reprogrammed */                                
  if ( ( ptimer->timer_data.it_interval.tv_sec  != 0 ) ||             
4000835c:	80 a0 60 00 	cmp  %g1, 0                                    
40008360:	12 80 00 0e 	bne  40008398 <_POSIX_Timer_TSR+0x4c>          
40008364:	c4 26 60 68 	st  %g2, [ %i1 + 0x68 ]                        
40008368:	c2 06 60 58 	ld  [ %i1 + 0x58 ], %g1                        
4000836c:	80 a0 60 00 	cmp  %g1, 0                                    
40008370:	32 80 00 0b 	bne,a   4000839c <_POSIX_Timer_TSR+0x50>       <== ALWAYS TAKEN
40008374:	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;                     
40008378:	82 10 20 04 	mov  4, %g1                                    <== NOT EXECUTED
4000837c:	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 ) ) {
40008380:	d0 06 60 38 	ld  [ %i1 + 0x38 ], %o0                        
40008384:	40 00 18 4c 	call  4000e4b4 <pthread_kill>                  
40008388:	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;                                                
4000838c:	c0 26 60 68 	clr  [ %i1 + 0x68 ]                            
40008390:	81 c7 e0 08 	ret                                            
40008394:	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(                           
40008398:	d2 06 60 64 	ld  [ %i1 + 0x64 ], %o1                        
4000839c:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
400083a0:	90 06 60 10 	add  %i1, 0x10, %o0                            
400083a4:	98 10 00 19 	mov  %i1, %o4                                  
400083a8:	17 10 00 20 	sethi  %hi(0x40008000), %o3                    
400083ac:	40 00 19 69 	call  4000e950 <_POSIX_Timer_Insert_helper>    
400083b0:	96 12 e3 4c 	or  %o3, 0x34c, %o3	! 4000834c <_POSIX_Timer_TSR>
      ptimer->ticks,                                                  
      ptimer->Object.id,                                              
      _POSIX_Timer_TSR,                                               
      ptimer                                                          
    );                                                                
    if ( !activated )                                                 
400083b4:	80 8a 20 ff 	btst  0xff, %o0                                
400083b8:	02 bf ff f6 	be  40008390 <_POSIX_Timer_TSR+0x44>           <== NEVER TAKEN
400083bc:	90 07 bf f8 	add  %fp, -8, %o0                              
400083c0:	13 10 00 83 	sethi  %hi(0x40020c00), %o1                    
400083c4:	40 00 06 3b 	call  40009cb0 <_TOD_Get_with_nanoseconds>     
400083c8:	92 12 61 48 	or  %o1, 0x148, %o1	! 40020d48 <_TOD>          
                                                                      
  /* After the signal handler returns, the count of expirations of the
   * timer must be set to 0.                                          
   */                                                                 
  ptimer->overrun = 0;                                                
}                                                                     
400083cc:	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);           
400083d0:	94 10 20 00 	clr  %o2                                       
400083d4:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400083d8:	90 10 00 1c 	mov  %i4, %o0                                  
400083dc:	96 12 e2 00 	or  %o3, 0x200, %o3                            
400083e0:	40 00 4a 34 	call  4001acb0 <__divdi3>                      
400083e4:	92 10 00 1d 	mov  %i5, %o1                                  
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
400083e8:	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);           
400083ec:	d2 26 60 6c 	st  %o1, [ %i1 + 0x6c ]                        
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
400083f0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400083f4:	90 10 00 1c 	mov  %i4, %o0                                  
400083f8:	96 12 e2 00 	or  %o3, 0x200, %o3                            
400083fc:	40 00 4b 18 	call  4001b05c <__moddi3>                      
40008400:	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;                     
40008404:	82 10 20 03 	mov  3, %g1                                    
40008408:	d2 26 60 70 	st  %o1, [ %i1 + 0x70 ]                        
4000840c:	10 bf ff dd 	b  40008380 <_POSIX_Timer_TSR+0x34>            
40008410:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       
                                                                      

400101d8 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) {
400101d8:	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,   
400101dc:	98 10 20 01 	mov  1, %o4                                    
400101e0:	90 10 00 18 	mov  %i0, %o0                                  
400101e4:	92 10 00 19 	mov  %i1, %o1                                  
400101e8:	94 07 bf cc 	add  %fp, -52, %o2                             
400101ec:	40 00 00 2e 	call  400102a4 <_POSIX_signals_Clear_signals>  
400101f0:	96 10 00 1a 	mov  %i2, %o3                                  
400101f4:	80 8a 20 ff 	btst  0xff, %o0                                
400101f8:	02 80 00 23 	be  40010284 <_POSIX_signals_Check_signal+0xac>
400101fc:	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 )        
40010200:	85 2e 60 02 	sll  %i1, 2, %g2                               
40010204:	37 10 00 82 	sethi  %hi(0x40020800), %i3                    
40010208:	b9 2e 60 04 	sll  %i1, 4, %i4                               
4001020c:	b6 16 e0 20 	or  %i3, 0x20, %i3                             
40010210:	b8 27 00 02 	sub  %i4, %g2, %i4                             
40010214:	84 06 c0 1c 	add  %i3, %i4, %g2                             
40010218:	fa 00 a0 08 	ld  [ %g2 + 8 ], %i5                           
4001021c:	80 a7 60 01 	cmp  %i5, 1                                    
40010220:	02 80 00 19 	be  40010284 <_POSIX_signals_Check_signal+0xac><== NEVER TAKEN
40010224:	21 10 00 81 	sethi  %hi(0x40020400), %l0                    
    return false;                                                     
                                                                      
  /*                                                                  
   *  Block the signals requested in sa_mask                          
   */                                                                 
  saved_signals_blocked = api->signals_blocked;                       
40010228:	f4 06 20 d0 	ld  [ %i0 + 0xd0 ], %i2                        
  api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;    
4001022c:	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,  
40010230:	a0 14 23 c0 	or  %l0, 0x3c0, %l0                            
40010234:	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;    
40010238:	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,  
4001023c:	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;    
40010240:	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,  
40010244:	92 02 60 20 	add  %o1, 0x20, %o1                            
40010248:	40 00 04 0f 	call  40011284 <memcpy>                        
4001024c:	94 10 20 28 	mov  0x28, %o2                                 
          sizeof( Thread_Wait_information ));                         
                                                                      
  /*                                                                  
   *  Here, the signal handler function executes                      
   */                                                                 
  switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {               
40010250:	c2 06 c0 1c 	ld  [ %i3 + %i4 ], %g1                         
40010254:	80 a0 60 02 	cmp  %g1, 2                                    
40010258:	02 80 00 0e 	be  40010290 <_POSIX_signals_Check_signal+0xb8>
4001025c:	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 );         
40010260:	9f c7 40 00 	call  %i5                                      
40010264:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Restore the blocking information                                
   */                                                                 
  memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,  
40010268:	d0 04 20 10 	ld  [ %l0 + 0x10 ], %o0                        
4001026c:	92 07 bf d8 	add  %fp, -40, %o1                             
40010270:	90 02 20 20 	add  %o0, 0x20, %o0                            
40010274:	40 00 04 04 	call  40011284 <memcpy>                        
40010278:	94 10 20 28 	mov  0x28, %o2                                 
  /*                                                                  
   *  Restore the previous set of blocked signals                     
   */                                                                 
  api->signals_blocked = saved_signals_blocked;                       
                                                                      
  return true;                                                        
4001027c:	82 10 20 01 	mov  1, %g1                                    
          sizeof( Thread_Wait_information ));                         
                                                                      
  /*                                                                  
   *  Restore the previous set of blocked signals                     
   */                                                                 
  api->signals_blocked = saved_signals_blocked;                       
40010280:	f4 26 20 d0 	st  %i2, [ %i0 + 0xd0 ]                        
                                                                      
  return true;                                                        
}                                                                     
40010284:	b0 08 60 01 	and  %g1, 1, %i0                               
40010288:	81 c7 e0 08 	ret                                            
4001028c:	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)(                
40010290:	92 07 bf cc 	add  %fp, -52, %o1                             
40010294:	9f c7 40 00 	call  %i5                                      
40010298:	94 10 20 00 	clr  %o2                                       
        signo,                                                        
        &siginfo_struct,                                              
        NULL        /* context is undefined per 1003.1b-1993, p. 66 */
      );                                                              
      break;                                                          
4001029c:	10 bf ff f4 	b  4001026c <_POSIX_signals_Check_signal+0x94> 
400102a0:	d0 04 20 10 	ld  [ %l0 + 0x10 ], %o0                        
                                                                      

40010898 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) {
40010898:	9d e3 bf a0 	save  %sp, -96, %sp                            
4001089c:	84 10 20 01 	mov  1, %g2                                    
400108a0:	82 06 3f ff 	add  %i0, -1, %g1                              
  clear_signal = true;                                                
  mask         = signo_to_mask( signo );                              
                                                                      
  ISR_Level  level;                                                   
                                                                      
  _ISR_Disable( level );                                              
400108a4:	7f ff c7 0b 	call  400024d0 <sparc_disable_interrupts>      
400108a8:	bb 28 80 01 	sll  %g2, %g1, %i5                             
    if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {   
400108ac:	05 10 00 82 	sethi  %hi(0x40020800), %g2                    
400108b0:	83 2e 20 02 	sll  %i0, 2, %g1                               
400108b4:	84 10 a0 20 	or  %g2, 0x20, %g2                             
400108b8:	b1 2e 20 04 	sll  %i0, 4, %i0                               
400108bc:	82 26 00 01 	sub  %i0, %g1, %g1                             
400108c0:	c4 00 80 01 	ld  [ %g2 + %g1 ], %g2                         
400108c4:	80 a0 a0 02 	cmp  %g2, 2                                    
400108c8:	02 80 00 08 	be  400108e8 <_POSIX_signals_Clear_process_signals+0x50>
400108cc:	31 10 00 82 	sethi  %hi(0x40020800), %i0                    
      if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )     
       clear_signal = false;                                          
    }                                                                 
    if ( clear_signal ) {                                             
      _POSIX_signals_Pending &= ~mask;                                
400108d0:	03 10 00 82 	sethi  %hi(0x40020800), %g1                    
400108d4:	c4 00 62 14 	ld  [ %g1 + 0x214 ], %g2	! 40020a14 <_POSIX_signals_Pending>
400108d8:	ba 28 80 1d 	andn  %g2, %i5, %i5                            
400108dc:	fa 20 62 14 	st  %i5, [ %g1 + 0x214 ]                       
    }                                                                 
  _ISR_Enable( level );                                               
400108e0:	7f ff c7 00 	call  400024e0 <sparc_enable_interrupts>       
400108e4:	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 ] ) )     
400108e8:	b0 16 22 18 	or  %i0, 0x218, %i0                            
400108ec:	c4 00 40 18 	ld  [ %g1 + %i0 ], %g2                         
400108f0:	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 );                            
400108f4:	b0 06 20 04 	add  %i0, 4, %i0                               
400108f8:	80 a0 80 18 	cmp  %g2, %i0                                  
400108fc:	02 bf ff f6 	be  400108d4 <_POSIX_signals_Clear_process_signals+0x3c><== ALWAYS TAKEN
40010900:	03 10 00 82 	sethi  %hi(0x40020800), %g1                    
       clear_signal = false;                                          
    }                                                                 
    if ( clear_signal ) {                                             
      _POSIX_signals_Pending &= ~mask;                                
    }                                                                 
  _ISR_Enable( level );                                               
40010904:	7f ff c6 f7 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40010908:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

40008ec0 <_POSIX_signals_Get_lowest>: sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40008ec0:	82 10 20 1b 	mov  0x1b, %g1                                 
40008ec4:	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(                                 
40008ec8:	84 00 7f ff 	add  %g1, -1, %g2                              
40008ecc:	85 28 c0 02 	sll  %g3, %g2, %g2                             
)                                                                     
{                                                                     
  int signo;                                                          
                                                                      
  for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {            
    if ( set & signo_to_mask( signo ) ) {                             
40008ed0:	80 88 80 08 	btst  %g2, %o0                                 
40008ed4:	12 80 00 11 	bne  40008f18 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
40008ed8:	01 00 00 00 	nop                                            
  sigset_t   set                                                      
)                                                                     
{                                                                     
  int signo;                                                          
                                                                      
  for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {            
40008edc:	82 00 60 01 	inc  %g1                                       
40008ee0:	80 a0 60 20 	cmp  %g1, 0x20                                 
40008ee4:	12 bf ff fa 	bne  40008ecc <_POSIX_signals_Get_lowest+0xc>  
40008ee8:	84 00 7f ff 	add  %g1, -1, %g2                              
40008eec:	82 10 20 01 	mov  1, %g1                                    
40008ef0:	10 80 00 05 	b  40008f04 <_POSIX_signals_Get_lowest+0x44>   
40008ef4:	86 10 20 01 	mov  1, %g3                                    
   */                                                                 
                                                                      
  #if (SIGHUP != 1)                                                   
    #error "Assumption that SIGHUP==1 violated!!"                     
  #endif                                                              
  for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {        
40008ef8:	80 a0 60 1b 	cmp  %g1, 0x1b                                 
40008efc:	02 80 00 07 	be  40008f18 <_POSIX_signals_Get_lowest+0x58>  <== NEVER TAKEN
40008f00:	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(                                 
40008f04:	84 00 7f ff 	add  %g1, -1, %g2                              
40008f08:	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 ) ) {                             
40008f0c:	80 88 80 08 	btst  %g2, %o0                                 
40008f10:	22 bf ff fa 	be,a   40008ef8 <_POSIX_signals_Get_lowest+0x38>
40008f14:	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;                                                       
}                                                                     
40008f18:	81 c3 e0 08 	retl                                           
40008f1c:	90 10 00 01 	mov  %g1, %o0                                  
                                                                      

4000dadc <_POSIX_signals_Post_switch_hook>: */ static void _POSIX_signals_Post_switch_hook( Thread_Control *the_thread ) {
4000dadc:	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;                   
4000dae0:	35 10 00 81 	sethi  %hi(0x40020400), %i2                    
  POSIX_API_Control  *api;                                            
  int                 signo;                                          
  ISR_Level           level;                                          
  int                 hold_errno;                                     
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
4000dae4:	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;                   
4000dae8:	b4 16 a3 c0 	or  %i2, 0x3c0, %i2                            
4000daec:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
                                                                      
  /*                                                                  
   * api may be NULL in case of a thread close in progress            
   */                                                                 
  if ( !api )                                                         
4000daf0:	80 a7 20 00 	cmp  %i4, 0                                    
4000daf4:	02 80 00 34 	be  4000dbc4 <_POSIX_signals_Post_switch_hook+0xe8><== NEVER TAKEN
4000daf8:	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 );                                            
4000dafc:	7f ff d2 75 	call  400024d0 <sparc_disable_interrupts>      
4000db00:	37 10 00 82 	sethi  %hi(0x40020800), %i3                    
4000db04:	b6 16 e2 14 	or  %i3, 0x214, %i3	! 40020a14 <_POSIX_signals_Pending>
      if ( !(~api->signals_blocked &                                  
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
4000db08:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
4000db0c:	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 &                                  
4000db10:	c4 07 20 d0 	ld  [ %i4 + 0xd0 ], %g2                        
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
4000db14:	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 &                                  
4000db18:	80 a8 40 02 	andncc  %g1, %g2, %g0                          
4000db1c:	02 80 00 26 	be  4000dbb4 <_POSIX_signals_Post_switch_hook+0xd8>
4000db20:	01 00 00 00 	nop                                            
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
       _ISR_Enable( level );                                          
       break;                                                         
     }                                                                
    _ISR_Enable( level );                                             
4000db24:	7f ff d2 6f 	call  400024e0 <sparc_enable_interrupts>       
4000db28:	ba 10 20 1b 	mov  0x1b, %i5	! 1b <PROM_START+0x1b>          
                                                                      
    for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {          
      _POSIX_signals_Check_signal( api, signo, false );               
4000db2c:	92 10 00 1d 	mov  %i5, %o1                                  
4000db30:	94 10 20 00 	clr  %o2                                       
4000db34:	40 00 09 a9 	call  400101d8 <_POSIX_signals_Check_signal>   
4000db38:	90 10 00 1c 	mov  %i4, %o0                                  
      _POSIX_signals_Check_signal( api, signo, true );                
4000db3c:	92 10 00 1d 	mov  %i5, %o1                                  
4000db40:	90 10 00 1c 	mov  %i4, %o0                                  
4000db44:	40 00 09 a5 	call  400101d8 <_POSIX_signals_Check_signal>   
4000db48:	94 10 20 01 	mov  1, %o2                                    
       _ISR_Enable( level );                                          
       break;                                                         
     }                                                                
    _ISR_Enable( level );                                             
                                                                      
    for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {          
4000db4c:	ba 07 60 01 	inc  %i5                                       
4000db50:	80 a7 60 20 	cmp  %i5, 0x20                                 
4000db54:	12 bf ff f7 	bne  4000db30 <_POSIX_signals_Post_switch_hook+0x54>
4000db58:	92 10 00 1d 	mov  %i5, %o1                                  
4000db5c:	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 );               
4000db60:	92 10 00 1d 	mov  %i5, %o1                                  
4000db64:	94 10 20 00 	clr  %o2                                       
4000db68:	40 00 09 9c 	call  400101d8 <_POSIX_signals_Check_signal>   
4000db6c:	90 10 00 1c 	mov  %i4, %o0                                  
      _POSIX_signals_Check_signal( api, signo, true );                
4000db70:	92 10 00 1d 	mov  %i5, %o1                                  
4000db74:	90 10 00 1c 	mov  %i4, %o0                                  
4000db78:	40 00 09 98 	call  400101d8 <_POSIX_signals_Check_signal>   
4000db7c:	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++ ) {      
4000db80:	ba 07 60 01 	inc  %i5                                       
4000db84:	80 a7 60 1b 	cmp  %i5, 0x1b                                 
4000db88:	12 bf ff f7 	bne  4000db64 <_POSIX_signals_Post_switch_hook+0x88>
4000db8c:	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 );                                            
4000db90:	7f ff d2 50 	call  400024d0 <sparc_disable_interrupts>      
4000db94:	01 00 00 00 	nop                                            
      if ( !(~api->signals_blocked &                                  
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
4000db98:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
4000db9c:	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 &                                  
4000dba0:	c4 07 20 d0 	ld  [ %i4 + 0xd0 ], %g2                        
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
4000dba4:	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 &                                  
4000dba8:	80 a8 40 02 	andncc  %g1, %g2, %g0                          
4000dbac:	12 bf ff de 	bne  4000db24 <_POSIX_signals_Post_switch_hook+0x48><== NEVER TAKEN
4000dbb0:	01 00 00 00 	nop                                            
            (api->signals_pending | _POSIX_signals_Pending)) ) {      
       _ISR_Enable( level );                                          
4000dbb4:	7f ff d2 4b 	call  400024e0 <sparc_enable_interrupts>       
4000dbb8:	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;                   
4000dbbc:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
4000dbc0:	f2 20 60 34 	st  %i1, [ %g1 + 0x34 ]                        
4000dbc4:	81 c7 e0 08 	ret                                            
4000dbc8:	81 e8 00 00 	restore                                        
                                                                      

4001cef8 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) {
4001cef8:	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 ) ) {
4001cefc:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4001cf00:	05 04 00 20 	sethi  %hi(0x10008000), %g2                    
4001cf04:	88 10 20 01 	mov  1, %g4                                    
4001cf08:	86 06 7f ff 	add  %i1, -1, %g3                              
4001cf0c:	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 ];               
4001cf10:	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 ) ) {
4001cf14:	80 a7 40 02 	cmp  %i5, %g2                                  
4001cf18:	02 80 00 2c 	be  4001cfc8 <_POSIX_signals_Unblock_thread+0xd0>
4001cf1c:	87 29 00 03 	sll  %g4, %g3, %g3                             
  }                                                                   
                                                                      
  /*                                                                  
   *  Thread is not waiting due to a sigwait.                         
   */                                                                 
  if ( ~api->signals_blocked & mask ) {                               
4001cf20:	c4 07 20 d0 	ld  [ %i4 + 0xd0 ], %g2                        
4001cf24:	80 a8 c0 02 	andncc  %g3, %g2, %g0                          
4001cf28:	02 80 00 24 	be  4001cfb8 <_POSIX_signals_Unblock_thread+0xc0>
4001cf2c:	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 ) ) {
4001cf30:	80 88 40 02 	btst  %g1, %g2                                 
4001cf34:	02 80 00 15 	be  4001cf88 <_POSIX_signals_Unblock_thread+0x90>
4001cf38:	80 a0 60 00 	cmp  %g1, 0                                    
      the_thread->Wait.return_code = EINTR;                           
4001cf3c:	84 10 20 04 	mov  4, %g2                                    
4001cf40:	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);              
4001cf44:	05 00 00 ef 	sethi  %hi(0x3bc00), %g2                       
4001cf48:	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) )
4001cf4c:	80 88 40 02 	btst  %g1, %g2                                 
4001cf50:	12 80 00 38 	bne  4001d030 <_POSIX_signals_Unblock_thread+0x138>
4001cf54:	80 88 60 08 	btst  8, %g1                                   
         _Thread_queue_Extract_with_proxy( the_thread );              
       else if ( _States_Is_delaying(the_thread->current_state) ) {   
4001cf58:	22 80 00 19 	be,a   4001cfbc <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
4001cf5c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
          (void) _Watchdog_Remove( &the_thread->Timer );              
4001cf60:	7f ff bb f5 	call  4000bf34 <_Watchdog_Remove>              
4001cf64:	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 );                  
4001cf68:	90 10 00 18 	mov  %i0, %o0                                  
4001cf6c:	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;                                                       
4001cf70:	b0 10 20 00 	clr  %i0                                       
4001cf74:	7f ff b7 68 	call  4000ad14 <_Thread_Clear_state>           
4001cf78:	92 12 63 f8 	or  %o1, 0x3f8, %o1                            
4001cf7c:	b0 0e 20 01 	and  %i0, 1, %i0                               
4001cf80:	81 c7 e0 08 	ret                                            
4001cf84:	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 ) {         
4001cf88:	32 80 00 0d 	bne,a   4001cfbc <_POSIX_signals_Unblock_thread+0xc4><== NEVER TAKEN
4001cf8c:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001cf90:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
4001cf94:	82 10 63 c0 	or  %g1, 0x3c0, %g1	! 400207c0 <_Per_CPU_Information>
4001cf98:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
4001cf9c:	80 a0 a0 00 	cmp  %g2, 0                                    
4001cfa0:	22 80 00 07 	be,a   4001cfbc <_POSIX_signals_Unblock_thread+0xc4>
4001cfa4:	b0 10 20 00 	clr  %i0                                       
4001cfa8:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4001cfac:	80 a6 00 02 	cmp  %i0, %g2                                  
4001cfb0:	22 80 00 02 	be,a   4001cfb8 <_POSIX_signals_Unblock_thread+0xc0><== ALWAYS TAKEN
4001cfb4:	c8 28 60 0c 	stb  %g4, [ %g1 + 0xc ]                        
        _Thread_Dispatch_necessary = true;                            
    }                                                                 
  }                                                                   
  return false;                                                       
4001cfb8:	b0 10 20 00 	clr  %i0                                       
}                                                                     
4001cfbc:	b0 0e 20 01 	and  %i0, 1, %i0                               
4001cfc0:	81 c7 e0 08 	ret                                            
4001cfc4:	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) ) {
4001cfc8:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
4001cfcc:	80 88 c0 01 	btst  %g3, %g1                                 
4001cfd0:	22 80 00 13 	be,a   4001d01c <_POSIX_signals_Unblock_thread+0x124>
4001cfd4:	c2 07 20 d0 	ld  [ %i4 + 0xd0 ], %g1                        
      the_thread->Wait.return_code = EINTR;                           
4001cfd8:	82 10 20 04 	mov  4, %g1                                    
4001cfdc:	c2 26 20 34 	st  %g1, [ %i0 + 0x34 ]                        
                                                                      
      the_info = (siginfo_t *) the_thread->Wait.return_argument;      
                                                                      
      if ( !info ) {                                                  
4001cfe0:	80 a6 a0 00 	cmp  %i2, 0                                    
4001cfe4:	02 80 00 19 	be  4001d048 <_POSIX_signals_Unblock_thread+0x150>
4001cfe8:	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;                                            
4001cfec:	c4 06 80 00 	ld  [ %i2 ], %g2                               
4001cff0:	c4 20 40 00 	st  %g2, [ %g1 ]                               
4001cff4:	c4 06 a0 04 	ld  [ %i2 + 4 ], %g2                           
4001cff8:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
4001cffc:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
4001d000:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
      }                                                               
                                                                      
      _Thread_queue_Extract_with_proxy( the_thread );                 
4001d004:	90 10 00 18 	mov  %i0, %o0                                  
4001d008:	7f ff ba 19 	call  4000b86c <_Thread_queue_Extract_with_proxy>
4001d00c:	b0 10 20 01 	mov  1, %i0                                    
      if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
        _Thread_Dispatch_necessary = true;                            
    }                                                                 
  }                                                                   
  return false;                                                       
}                                                                     
4001d010:	b0 0e 20 01 	and  %i0, 1, %i0                               
4001d014:	81 c7 e0 08 	ret                                            
4001d018:	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) ) {
4001d01c:	80 a8 c0 01 	andncc  %g3, %g1, %g0                          
4001d020:	32 bf ff ef 	bne,a   4001cfdc <_POSIX_signals_Unblock_thread+0xe4>
4001d024:	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;                                                       
4001d028:	10 bf ff e5 	b  4001cfbc <_POSIX_signals_Unblock_thread+0xc4>
4001d02c:	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 );              
4001d030:	90 10 00 18 	mov  %i0, %o0                                  
4001d034:	7f ff ba 0e 	call  4000b86c <_Thread_queue_Extract_with_proxy>
4001d038:	b0 10 20 00 	clr  %i0                                       
4001d03c:	b0 0e 20 01 	and  %i0, 1, %i0                               
4001d040:	81 c7 e0 08 	ret                                            
4001d044:	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;                                  
4001d048:	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;                                   
4001d04c:	f2 20 40 00 	st  %i1, [ %g1 ]                               
        the_info->si_code = SI_USER;                                  
4001d050:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
        the_info->si_value.sival_int = 0;                             
4001d054:	10 bf ff ec 	b  4001d004 <_POSIX_signals_Unblock_thread+0x10c>
4001d058:	c0 20 60 08 	clr  [ %g1 + 8 ]                               
                                                                      

4000aff4 <_RBTree_Extract_unprotected>: */ void _RBTree_Extract_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) {
4000aff4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  RBTree_Node *leaf, *target;                                         
  RBTree_Color victim_color;                                          
  RBTree_Direction dir;                                               
                                                                      
  if (!the_node) return;                                              
4000aff8:	80 a6 60 00 	cmp  %i1, 0                                    
4000affc:	02 80 00 4c 	be  4000b12c <_RBTree_Extract_unprotected+0x138>
4000b000:	01 00 00 00 	nop                                            
                                                                      
  /* check if min needs to be updated */                              
  if (the_node == the_rbtree->first[RBT_LEFT]) {                      
4000b004:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
4000b008:	80 a0 40 19 	cmp  %g1, %i1                                  
4000b00c:	02 80 00 56 	be  4000b164 <_RBTree_Extract_unprotected+0x170>
4000b010:	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]) {                     
4000b014:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4000b018:	80 a0 40 19 	cmp  %g1, %i1                                  
4000b01c:	02 80 00 56 	be  4000b174 <_RBTree_Extract_unprotected+0x180>
4000b020:	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]) {      
4000b024:	fa 06 60 04 	ld  [ %i1 + 4 ], %i5                           
4000b028:	80 a7 60 00 	cmp  %i5, 0                                    
4000b02c:	22 80 00 5a 	be,a   4000b194 <_RBTree_Extract_unprotected+0x1a0>
4000b030:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
4000b034:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4000b038:	80 a0 60 00 	cmp  %g1, 0                                    
4000b03c:	32 80 00 05 	bne,a   4000b050 <_RBTree_Extract_unprotected+0x5c>
4000b040:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000b044:	10 80 00 3c 	b  4000b134 <_RBTree_Extract_unprotected+0x140>
4000b048:	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];
4000b04c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000b050:	80 a0 60 00 	cmp  %g1, 0                                    
4000b054:	32 bf ff fe 	bne,a   4000b04c <_RBTree_Extract_unprotected+0x58>
4000b058:	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];                                   
4000b05c:	f8 07 60 04 	ld  [ %i5 + 4 ], %i4                           
    if(leaf) {                                                        
4000b060:	80 a7 20 00 	cmp  %i4, 0                                    
4000b064:	02 80 00 48 	be  4000b184 <_RBTree_Extract_unprotected+0x190>
4000b068:	01 00 00 00 	nop                                            
      leaf->parent = target->parent;                                  
4000b06c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4000b070:	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];                         
4000b074:	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];                     
4000b078:	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];                         
4000b07c:	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;                                     
4000b080:	c6 07 60 0c 	ld  [ %i5 + 0xc ], %g3                         
    dir = target != target->parent->child[0];                         
4000b084:	88 1f 40 04 	xor  %i5, %g4, %g4                             
4000b088:	80 a0 00 04 	cmp  %g0, %g4                                  
4000b08c:	88 40 20 00 	addx  %g0, 0, %g4                              
    target->parent->child[dir] = leaf;                                
4000b090:	89 29 20 02 	sll  %g4, 2, %g4                               
4000b094:	84 00 80 04 	add  %g2, %g4, %g2                             
4000b098:	f8 20 a0 04 	st  %i4, [ %g2 + 4 ]                           
                                                                      
    /* now replace the_node with target */                            
    dir = the_node != the_node->parent->child[0];                     
4000b09c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000b0a0:	84 18 80 19 	xor  %g2, %i1, %g2                             
4000b0a4:	80 a0 00 02 	cmp  %g0, %g2                                  
4000b0a8:	84 40 20 00 	addx  %g0, 0, %g2                              
    the_node->parent->child[dir] = target;                            
4000b0ac:	85 28 a0 02 	sll  %g2, 2, %g2                               
4000b0b0:	82 00 40 02 	add  %g1, %g2, %g1                             
4000b0b4:	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];            
4000b0b8:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4000b0bc:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
    if (the_node->child[RBT_RIGHT])                                   
4000b0c0:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4000b0c4:	80 a0 60 00 	cmp  %g1, 0                                    
4000b0c8:	32 80 00 02 	bne,a   4000b0d0 <_RBTree_Extract_unprotected+0xdc><== ALWAYS TAKEN
4000b0cc:	fa 20 40 00 	st  %i5, [ %g1 ]                               
      the_node->child[RBT_RIGHT]->parent = target;                    
    target->child[RBT_LEFT] = the_node->child[RBT_LEFT];              
4000b0d0:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
4000b0d4:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
    if (the_node->child[RBT_LEFT])                                    
4000b0d8:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
4000b0dc:	80 a0 60 00 	cmp  %g1, 0                                    
4000b0e0:	32 80 00 02 	bne,a   4000b0e8 <_RBTree_Extract_unprotected+0xf4>
4000b0e4:	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;                                
4000b0e8:	c4 06 40 00 	ld  [ %i1 ], %g2                               
    target->color = the_node->color;                                  
4000b0ec:	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;                                
4000b0f0:	c4 27 40 00 	st  %g2, [ %i5 ]                               
    target->color = the_node->color;                                  
4000b0f4:	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 */             
4000b0f8:	80 a0 e0 00 	cmp  %g3, 0                                    
4000b0fc:	32 80 00 06 	bne,a   4000b114 <_RBTree_Extract_unprotected+0x120>
4000b100:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
    if (leaf) {                                                       
4000b104:	80 a7 20 00 	cmp  %i4, 0                                    
4000b108:	32 80 00 02 	bne,a   4000b110 <_RBTree_Extract_unprotected+0x11c>
4000b10c:	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;          
4000b110:	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;
4000b114:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
4000b118:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
4000b11c:	80 a0 60 00 	cmp  %g1, 0                                    
4000b120:	02 80 00 03 	be  4000b12c <_RBTree_Extract_unprotected+0x138>
4000b124:	c0 26 40 00 	clr  [ %i1 ]                                   
4000b128:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
4000b12c:	81 c7 e0 08 	ret                                            
4000b130:	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;                                
4000b134:	c2 06 40 00 	ld  [ %i1 ], %g1                               
4000b138:	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];                     
4000b13c:	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;                                   
4000b140:	c6 06 60 0c 	ld  [ %i1 + 0xc ], %g3                         
                                                                      
    /* remove the_node from the tree */                               
    dir = the_node != the_node->parent->child[0];                     
4000b144:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000b148:	84 18 80 19 	xor  %g2, %i1, %g2                             
4000b14c:	80 a0 00 02 	cmp  %g0, %g2                                  
4000b150:	84 40 20 00 	addx  %g0, 0, %g2                              
    the_node->parent->child[dir] = leaf;                              
4000b154:	85 28 a0 02 	sll  %g2, 2, %g2                               
4000b158:	82 00 40 02 	add  %g1, %g2, %g1                             
4000b15c:	10 bf ff e7 	b  4000b0f8 <_RBTree_Extract_unprotected+0x104>
4000b160:	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 );                 
4000b164:	40 00 00 eb 	call  4000b510 <_RBTree_Next_unprotected>      
4000b168:	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;                               
4000b16c:	10 bf ff aa 	b  4000b014 <_RBTree_Extract_unprotected+0x20> 
4000b170:	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 );                  
4000b174:	40 00 00 e7 	call  4000b510 <_RBTree_Next_unprotected>      
4000b178:	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;                          
4000b17c:	10 bf ff aa 	b  4000b024 <_RBTree_Extract_unprotected+0x30> 
4000b180:	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);                   
4000b184:	7f ff fe d3 	call  4000acd0 <_RBTree_Extract_validate_unprotected>
4000b188:	90 10 00 1d 	mov  %i5, %o0                                  
    }                                                                 
    victim_color = target->color;                                     
    dir = target != target->parent->child[0];                         
4000b18c:	10 bf ff bb 	b  4000b078 <_RBTree_Extract_unprotected+0x84> 
4000b190:	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 ) {                                                      
4000b194:	80 a7 20 00 	cmp  %i4, 0                                    
4000b198:	32 bf ff e8 	bne,a   4000b138 <_RBTree_Extract_unprotected+0x144>
4000b19c:	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);                 
4000b1a0:	7f ff fe cc 	call  4000acd0 <_RBTree_Extract_validate_unprotected>
4000b1a4:	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];                     
4000b1a8:	10 bf ff e6 	b  4000b140 <_RBTree_Extract_unprotected+0x14c>
4000b1ac:	c2 06 40 00 	ld  [ %i1 ], %g1                               
                                                                      

4000acd0 <_RBTree_Extract_validate_unprotected>: ) { RBTree_Node *parent, *sibling; RBTree_Direction dir; parent = the_node->parent;
4000acd0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
  if(!parent->parent) return;                                         
4000acd4:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000acd8:	80 a0 a0 00 	cmp  %g2, 0                                    
4000acdc:	02 80 00 3f 	be  4000add8 <_RBTree_Extract_validate_unprotected+0x108>
4000ace0:	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])                   
4000ace4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000ace8:	80 a2 00 02 	cmp  %o0, %g2                                  
4000acec:	22 80 00 02 	be,a   4000acf4 <_RBTree_Extract_validate_unprotected+0x24>
4000acf0:	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);                    
4000acf4:	c6 02 20 0c 	ld  [ %o0 + 0xc ], %g3                         
4000acf8:	80 a0 e0 01 	cmp  %g3, 1                                    
4000acfc:	02 80 00 32 	be  4000adc4 <_RBTree_Extract_validate_unprotected+0xf4>
4000ad00:	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) {               
4000ad04:	c6 00 40 00 	ld  [ %g1 ], %g3                               
4000ad08:	80 a0 e0 00 	cmp  %g3, 0                                    
4000ad0c:	02 80 00 2e 	be  4000adc4 <_RBTree_Extract_validate_unprotected+0xf4>
4000ad10:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ad14:	22 80 00 07 	be,a   4000ad30 <_RBTree_Extract_validate_unprotected+0x60><== NEVER TAKEN
4000ad18:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           <== NOT EXECUTED
4000ad1c:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
4000ad20:	80 a1 20 01 	cmp  %g4, 1                                    
4000ad24:	22 80 00 63 	be,a   4000aeb0 <_RBTree_Extract_validate_unprotected+0x1e0>
4000ad28:	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]) &&                 
4000ad2c:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
4000ad30:	80 a0 e0 00 	cmp  %g3, 0                                    
4000ad34:	22 80 00 07 	be,a   4000ad50 <_RBTree_Extract_validate_unprotected+0x80>
4000ad38:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
4000ad3c:	c6 00 e0 0c 	ld  [ %g3 + 0xc ], %g3                         
4000ad40:	80 a0 e0 01 	cmp  %g3, 1                                    
4000ad44:	22 80 00 29 	be,a   4000ade8 <_RBTree_Extract_validate_unprotected+0x118>
4000ad48:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
        !_RBTree_Is_red(sibling->child[RBT_LEFT])) {                  
4000ad4c:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
4000ad50:	80 a0 e0 00 	cmp  %g3, 0                                    
4000ad54:	22 80 00 07 	be,a   4000ad70 <_RBTree_Extract_validate_unprotected+0xa0>
4000ad58:	da 20 a0 0c 	st  %o5, [ %g2 + 0xc ]                         
4000ad5c:	c6 00 e0 0c 	ld  [ %g3 + 0xc ], %g3                         
4000ad60:	80 a0 e0 01 	cmp  %g3, 1                                    
4000ad64:	22 80 00 21 	be,a   4000ade8 <_RBTree_Extract_validate_unprotected+0x118>
4000ad68:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
        sibling->color = RBT_RED;                                     
4000ad6c:	da 20 a0 0c 	st  %o5, [ %g2 + 0xc ]                         
4000ad70:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000ad74:	80 a0 a0 01 	cmp  %g2, 1                                    
4000ad78:	22 80 00 99 	be,a   4000afdc <_RBTree_Extract_validate_unprotected+0x30c>
4000ad7c:	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;                                    
4000ad80:	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;                                
4000ad84:	80 a0 e0 00 	cmp  %g3, 0                                    
4000ad88:	02 80 00 6c 	be  4000af38 <_RBTree_Extract_validate_unprotected+0x268><== NEVER TAKEN
4000ad8c:	90 10 00 01 	mov  %g1, %o0                                  
  if(!(the_node->parent->parent)) return NULL;                        
4000ad90:	c4 00 c0 00 	ld  [ %g3 ], %g2                               
4000ad94:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ad98:	02 80 00 69 	be  4000af3c <_RBTree_Extract_validate_unprotected+0x26c>
4000ad9c:	84 10 20 00 	clr  %g2                                       
                                                                      
  if(the_node == the_node->parent->child[RBT_LEFT])                   
4000ada0:	c4 00 e0 04 	ld  [ %g3 + 4 ], %g2                           
4000ada4:	80 a0 40 02 	cmp  %g1, %g2                                  
4000ada8:	22 80 00 0e 	be,a   4000ade0 <_RBTree_Extract_validate_unprotected+0x110>
4000adac:	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;                                
4000adb0:	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);                    
4000adb4:	c6 02 20 0c 	ld  [ %o0 + 0xc ], %g3                         
4000adb8:	80 a0 e0 01 	cmp  %g3, 1                                    
4000adbc:	32 bf ff d3 	bne,a   4000ad08 <_RBTree_Extract_validate_unprotected+0x38><== ALWAYS TAKEN
4000adc0:	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;          
4000adc4:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000adc8:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000adcc:	80 a0 60 00 	cmp  %g1, 0                                    
4000add0:	02 80 00 5f 	be  4000af4c <_RBTree_Extract_validate_unprotected+0x27c>
4000add4:	01 00 00 00 	nop                                            
4000add8:	81 c3 e0 08 	retl                                           
4000addc:	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;                                
4000ade0:	10 bf ff f5 	b  4000adb4 <_RBTree_Extract_validate_unprotected+0xe4>
4000ade4:	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];                             
4000ade8:	86 1a 00 03 	xor  %o0, %g3, %g3                             
4000adec:	80 a0 00 03 	cmp  %g0, %g3                                  
4000adf0:	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);                         
4000adf4:	86 1b 60 01 	xor  %o5, 1, %g3                               
      if (!_RBTree_Is_red(sibling->child[_RBTree_Opposite_direction(dir)])) {
4000adf8:	87 28 e0 02 	sll  %g3, 2, %g3                               
4000adfc:	88 00 80 03 	add  %g2, %g3, %g4                             
4000ae00:	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);                    
4000ae04:	80 a1 20 00 	cmp  %g4, 0                                    
4000ae08:	22 80 00 07 	be,a   4000ae24 <_RBTree_Extract_validate_unprotected+0x154>
4000ae0c:	9b 2b 60 02 	sll  %o5, 2, %o5                               
4000ae10:	d8 01 20 0c 	ld  [ %g4 + 0xc ], %o4                         
4000ae14:	80 a3 20 01 	cmp  %o4, 1                                    
4000ae18:	22 80 00 4f 	be,a   4000af54 <_RBTree_Extract_validate_unprotected+0x284>
4000ae1c:	d6 00 60 0c 	ld  [ %g1 + 0xc ], %o3                         
        sibling->color = RBT_RED;                                     
        sibling->child[dir]->color = RBT_BLACK;                       
4000ae20:	9b 2b 60 02 	sll  %o5, 2, %o5                               
4000ae24:	98 00 80 0d 	add  %g2, %o5, %o4                             
4000ae28:	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;                                     
4000ae2c:	96 10 20 01 	mov  1, %o3                                    
4000ae30:	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;
4000ae34:	80 a1 20 00 	cmp  %g4, 0                                    
4000ae38:	02 80 00 15 	be  4000ae8c <_RBTree_Extract_validate_unprotected+0x1bc><== NEVER TAKEN
4000ae3c:	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];   
4000ae40:	96 01 00 03 	add  %g4, %g3, %o3                             
4000ae44:	d4 02 e0 04 	ld  [ %o3 + 4 ], %o2                           
4000ae48:	d4 23 20 04 	st  %o2, [ %o4 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
4000ae4c:	d8 02 e0 04 	ld  [ %o3 + 4 ], %o4                           
4000ae50:	80 a3 20 00 	cmp  %o4, 0                                    
4000ae54:	32 80 00 02 	bne,a   4000ae5c <_RBTree_Extract_validate_unprotected+0x18c>
4000ae58:	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;
4000ae5c:	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;                                           
4000ae60:	96 01 00 03 	add  %g4, %g3, %o3                             
4000ae64:	c4 22 e0 04 	st  %g2, [ %o3 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000ae68:	d6 03 20 04 	ld  [ %o4 + 4 ], %o3                           
                                                                      
  c->parent = the_node->parent;                                       
4000ae6c:	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;
4000ae70:	96 18 80 0b 	xor  %g2, %o3, %o3                             
                                                                      
  c->parent = the_node->parent;                                       
  the_node->parent = c;                                               
4000ae74:	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;
4000ae78:	80 a0 00 0b 	cmp  %g0, %o3                                  
4000ae7c:	84 40 20 00 	addx  %g0, 0, %g2                              
4000ae80:	85 28 a0 02 	sll  %g2, 2, %g2                               
4000ae84:	98 03 00 02 	add  %o4, %g2, %o4                             
4000ae88:	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;                                 
4000ae8c:	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)];     
4000ae90:	84 00 40 03 	add  %g1, %g3, %g2                             
4000ae94:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
      }                                                               
      sibling->color = parent->color;                                 
4000ae98:	c8 20 a0 0c 	st  %g4, [ %g2 + 0xc ]                         
4000ae9c:	88 00 80 03 	add  %g2, %g3, %g4                             
4000aea0:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
      parent->color = RBT_BLACK;                                      
4000aea4:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
      sibling->child[_RBTree_Opposite_direction(dir)]->color = RBT_BLACK;
4000aea8:	10 80 00 33 	b  4000af74 <_RBTree_Extract_validate_unprotected+0x2a4>
4000aeac:	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;                                        
4000aeb0:	c8 20 60 0c 	st  %g4, [ %g1 + 0xc ]                         
      sibling->color = RBT_BLACK;                                     
      dir = the_node != parent->child[0];                             
4000aeb4:	88 1b 00 08 	xor  %o4, %o0, %g4                             
4000aeb8:	80 a0 00 04 	cmp  %g0, %g4                                  
4000aebc:	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);                         
4000aec0:	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;
4000aec4:	97 2a e0 02 	sll  %o3, 2, %o3                               
4000aec8:	98 00 40 0b 	add  %g1, %o3, %o4                             
4000aecc:	c8 03 20 04 	ld  [ %o4 + 4 ], %g4                           
4000aed0:	80 a1 20 00 	cmp  %g4, 0                                    
4000aed4:	02 80 00 1c 	be  4000af44 <_RBTree_Extract_validate_unprotected+0x274><== NEVER TAKEN
4000aed8:	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];   
4000aedc:	95 2a a0 02 	sll  %o2, 2, %o2                               
4000aee0:	84 01 00 0a 	add  %g4, %o2, %g2                             
4000aee4:	d2 00 a0 04 	ld  [ %g2 + 4 ], %o1                           
4000aee8:	d2 23 20 04 	st  %o1, [ %o4 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
4000aeec:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
4000aef0:	80 a0 a0 00 	cmp  %g2, 0                                    
4000aef4:	02 80 00 04 	be  4000af04 <_RBTree_Extract_validate_unprotected+0x234><== NEVER TAKEN
4000aef8:	94 01 00 0a 	add  %g4, %o2, %o2                             
    c->child[dir]->parent = the_node;                                 
4000aefc:	c2 20 80 00 	st  %g1, [ %g2 ]                               
4000af00:	c6 00 40 00 	ld  [ %g1 ], %g3                               
                                                                      
  c->child[dir] = the_node;                                           
4000af04:	c2 22 a0 04 	st  %g1, [ %o2 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000af08:	c4 00 e0 04 	ld  [ %g3 + 4 ], %g2                           
                                                                      
  c->parent = the_node->parent;                                       
4000af0c:	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;
4000af10:	84 18 40 02 	xor  %g1, %g2, %g2                             
4000af14:	80 a0 00 02 	cmp  %g0, %g2                                  
4000af18:	84 40 20 00 	addx  %g0, 0, %g2                              
4000af1c:	85 28 a0 02 	sll  %g2, 2, %g2                               
4000af20:	96 00 40 0b 	add  %g1, %o3, %o3                             
4000af24:	86 00 c0 02 	add  %g3, %g2, %g3                             
                                                                      
  c->parent = the_node->parent;                                       
  the_node->parent = c;                                               
4000af28:	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;
4000af2c:	c8 20 e0 04 	st  %g4, [ %g3 + 4 ]                           
4000af30:	10 bf ff 7f 	b  4000ad2c <_RBTree_Extract_validate_unprotected+0x5c>
4000af34:	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;                                
4000af38:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
4000af3c:	10 bf ff 9e 	b  4000adb4 <_RBTree_Extract_validate_unprotected+0xe4>
4000af40:	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;
4000af44:	10 bf ff 7a 	b  4000ad2c <_RBTree_Extract_validate_unprotected+0x5c><== NOT EXECUTED
4000af48:	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;          
4000af4c:	81 c3 e0 08 	retl                                           
4000af50:	c0 22 20 0c 	clr  [ %o0 + 0xc ]                             
4000af54:	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;                                 
4000af58:	d6 20 a0 0c 	st  %o3, [ %g2 + 0xc ]                         
      parent->color = RBT_BLACK;                                      
4000af5c:	c0 20 60 0c 	clr  [ %g1 + 0xc ]                             
4000af60:	c4 03 20 04 	ld  [ %o4 + 4 ], %g2                           
4000af64:	80 a0 a0 00 	cmp  %g2, 0                                    
4000af68:	02 bf ff 97 	be  4000adc4 <_RBTree_Extract_validate_unprotected+0xf4><== NEVER TAKEN
4000af6c:	c0 21 20 0c 	clr  [ %g4 + 0xc ]                             
4000af70:	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];   
4000af74:	88 00 80 0d 	add  %g2, %o5, %g4                             
4000af78:	d8 01 20 04 	ld  [ %g4 + 4 ], %o4                           
4000af7c:	86 00 40 03 	add  %g1, %g3, %g3                             
4000af80:	d8 20 e0 04 	st  %o4, [ %g3 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
4000af84:	c6 01 20 04 	ld  [ %g4 + 4 ], %g3                           
4000af88:	80 a0 e0 00 	cmp  %g3, 0                                    
4000af8c:	32 80 00 02 	bne,a   4000af94 <_RBTree_Extract_validate_unprotected+0x2c4>
4000af90:	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;
4000af94:	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;                                           
4000af98:	9a 00 80 0d 	add  %g2, %o5, %o5                             
4000af9c:	c2 23 60 04 	st  %g1, [ %o5 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000afa0:	c8 00 e0 04 	ld  [ %g3 + 4 ], %g4                           
                                                                      
  c->parent = the_node->parent;                                       
4000afa4:	c6 20 80 00 	st  %g3, [ %g2 ]                               
  the_node->parent = c;                                               
4000afa8:	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;
4000afac:	88 18 40 04 	xor  %g1, %g4, %g4                             
4000afb0:	80 a0 00 04 	cmp  %g0, %g4                                  
4000afb4:	82 40 20 00 	addx  %g0, 0, %g1                              
4000afb8:	83 28 60 02 	sll  %g1, 2, %g1                               
4000afbc:	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;          
4000afc0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000afc4:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
4000afc8:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000afcc:	80 a0 60 00 	cmp  %g1, 0                                    
4000afd0:	12 bf ff 82 	bne  4000add8 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
4000afd4:	01 00 00 00 	nop                                            
4000afd8:	30 bf ff dd 	b,a   4000af4c <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
4000afdc:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000afe0:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000afe4:	80 a0 60 00 	cmp  %g1, 0                                    
4000afe8:	12 bf ff 7c 	bne  4000add8 <_RBTree_Extract_validate_unprotected+0x108><== ALWAYS TAKEN
4000afec:	01 00 00 00 	nop                                            
4000aff0:	30 bf ff d7 	b,a   4000af4c <_RBTree_Extract_validate_unprotected+0x27c><== NOT EXECUTED
                                                                      

4000be8c <_RBTree_Find>: RBTree_Node *_RBTree_Find( RBTree_Control *the_rbtree, RBTree_Node *search_node ) {
4000be8c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level          level;                                           
  RBTree_Node *return_node;                                           
                                                                      
  return_node = NULL;                                                 
  _ISR_Disable( level );                                              
4000be90:	7f ff df 23 	call  40003b1c <sparc_disable_interrupts>      
4000be94:	b8 10 00 18 	mov  %i0, %i4                                  
4000be98:	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;                          
4000be9c:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
4000bea0:	80 a7 60 00 	cmp  %i5, 0                                    
4000bea4:	02 80 00 15 	be  4000bef8 <_RBTree_Find+0x6c>               <== NEVER TAKEN
4000bea8:	b0 10 20 00 	clr  %i0                                       
    compare_result = the_rbtree->compare_function(the_node, iter_node);
4000beac:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
4000beb0:	92 10 00 1d 	mov  %i5, %o1                                  
4000beb4:	9f c0 40 00 	call  %g1                                      
4000beb8:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(                         
  int compare_result                                                  
)                                                                     
{                                                                     
  return compare_result > 0;                                          
4000bebc:	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 ) ) {                       
4000bec0:	80 a2 20 00 	cmp  %o0, 0                                    
                                                                      
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(                         
  int compare_result                                                  
)                                                                     
{                                                                     
  return compare_result > 0;                                          
4000bec4:	82 20 40 08 	sub  %g1, %o0, %g1                             
4000bec8:	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];                                
4000becc:	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 ) ) {                       
4000bed0:	12 80 00 06 	bne  4000bee8 <_RBTree_Find+0x5c>              
4000bed4:	82 07 40 01 	add  %i5, %g1, %g1                             
      found = iter_node;                                              
      if ( the_rbtree->is_unique )                                    
4000bed8:	c4 0f 20 14 	ldub  [ %i4 + 0x14 ], %g2                      
4000bedc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000bee0:	12 80 00 0a 	bne  4000bf08 <_RBTree_Find+0x7c>              
4000bee4:	b0 10 00 1d 	mov  %i5, %i0                                  
        break;                                                        
    }                                                                 
                                                                      
    RBTree_Direction dir =                                            
      (RBTree_Direction) _RBTree_Is_greater( compare_result );        
    iter_node = iter_node->child[dir];                                
4000bee8:	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) {                                                 
4000beec:	80 a7 60 00 	cmp  %i5, 0                                    
4000bef0:	32 bf ff f0 	bne,a   4000beb0 <_RBTree_Find+0x24>           
4000bef4:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
      return_node = _RBTree_Find_unprotected( the_rbtree, search_node );
  _ISR_Enable( level );                                               
4000bef8:	7f ff df 0d 	call  40003b2c <sparc_enable_interrupts>       
4000befc:	90 10 00 1b 	mov  %i3, %o0                                  
  return return_node;                                                 
}                                                                     
4000bf00:	81 c7 e0 08 	ret                                            
4000bf04:	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 );                                               
4000bf08:	7f ff df 09 	call  40003b2c <sparc_enable_interrupts>       
4000bf0c:	90 10 00 1b 	mov  %i3, %o0                                  
  return return_node;                                                 
}                                                                     
4000bf10:	81 c7 e0 08 	ret                                            
4000bf14:	81 e8 00 00 	restore                                        
                                                                      

4000c2f8 <_RBTree_Initialize>: void *starting_address, size_t number_nodes, size_t node_size, bool is_unique ) {
4000c2f8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  size_t      count;                                                  
  RBTree_Node *next;                                                  
                                                                      
  /* TODO: Error message? */                                          
  if (!the_rbtree) return;                                            
4000c2fc:	80 a6 20 00 	cmp  %i0, 0                                    
4000c300:	02 80 00 0f 	be  4000c33c <_RBTree_Initialize+0x44>         <== NEVER TAKEN
4000c304:	80 a6 e0 00 	cmp  %i3, 0                                    
    RBTree_Control          *the_rbtree,                              
    RBTree_Compare_function  compare_function,                        
    bool                     is_unique                                
    )                                                                 
{                                                                     
  the_rbtree->permanent_null   = NULL;                                
4000c308:	c0 26 00 00 	clr  [ %i0 ]                                   
  the_rbtree->root             = NULL;                                
4000c30c:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
  the_rbtree->first[0]         = NULL;                                
4000c310:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
  the_rbtree->first[1]         = NULL;                                
4000c314:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
  the_rbtree->compare_function = compare_function;                    
4000c318:	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-- ) {                                                 
4000c31c:	02 80 00 08 	be  4000c33c <_RBTree_Initialize+0x44>         <== NEVER TAKEN
4000c320:	fa 2e 20 14 	stb  %i5, [ %i0 + 0x14 ]                       
    _RBTree_Insert_unprotected(the_rbtree, next);                     
4000c324:	92 10 00 1a 	mov  %i2, %o1                                  
4000c328:	7f ff ff 0b 	call  4000bf54 <_RBTree_Insert_unprotected>    
4000c32c:	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-- ) {                                                 
4000c330:	b6 86 ff ff 	addcc  %i3, -1, %i3                            
4000c334:	12 bf ff fc 	bne  4000c324 <_RBTree_Initialize+0x2c>        
4000c338:	b4 06 80 1c 	add  %i2, %i4, %i2                             
4000c33c:	81 c7 e0 08 	ret                                            
4000c340:	81 e8 00 00 	restore                                        
                                                                      

4000b1d4 <_RBTree_Insert_unprotected>: */ RBTree_Node *_RBTree_Insert_unprotected( RBTree_Control *the_rbtree, RBTree_Node *the_node ) {
4000b1d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if(!the_node) return (RBTree_Node*)-1;                              
4000b1d8:	80 a6 60 00 	cmp  %i1, 0                                    
4000b1dc:	02 80 00 9c 	be  4000b44c <_RBTree_Insert_unprotected+0x278>
4000b1e0:	b8 10 00 18 	mov  %i0, %i4                                  
                                                                      
  RBTree_Node *iter_node = the_rbtree->root;                          
4000b1e4:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
  int compare_result;                                                 
                                                                      
  if (!iter_node) { /* special case: first node inserted */           
4000b1e8:	80 a7 60 00 	cmp  %i5, 0                                    
4000b1ec:	32 80 00 05 	bne,a   4000b200 <_RBTree_Insert_unprotected+0x2c>
4000b1f0:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
    the_node->color = RBT_BLACK;                                      
4000b1f4:	10 80 00 9a 	b  4000b45c <_RBTree_Insert_unprotected+0x288> 
4000b1f8:	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);
4000b1fc:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
4000b200:	92 10 00 1d 	mov  %i5, %o1                                  
4000b204:	9f c0 40 00 	call  %g1                                      
4000b208:	90 10 00 19 	mov  %i1, %o0                                  
      if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
4000b20c:	c4 0f 20 14 	ldub  [ %i4 + 0x14 ], %g2                      
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
4000b210:	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 ) )
4000b214:	80 a0 a0 00 	cmp  %g2, 0                                    
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
4000b218:	b7 36 e0 1f 	srl  %i3, 0x1f, %i3                            
      if (!iter_node->child[dir]) {                                   
4000b21c:	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 ) )
4000b220:	02 80 00 05 	be  4000b234 <_RBTree_Insert_unprotected+0x60> 
4000b224:	82 07 40 01 	add  %i5, %g1, %g1                             
4000b228:	80 a2 20 00 	cmp  %o0, 0                                    
4000b22c:	02 80 00 8a 	be  4000b454 <_RBTree_Insert_unprotected+0x280>
4000b230:	01 00 00 00 	nop                                            
        return iter_node;                                             
      RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );    
      if (!iter_node->child[dir]) {                                   
4000b234:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
4000b238:	80 a6 20 00 	cmp  %i0, 0                                    
4000b23c:	32 bf ff f0 	bne,a   4000b1fc <_RBTree_Insert_unprotected+0x28>
4000b240:	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(                
4000b244:	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];                                      
4000b248:	b4 06 e0 02 	add  %i3, 2, %i2                               
4000b24c:	87 2e a0 02 	sll  %i2, 2, %g3                               
4000b250:	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;
4000b254:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
4000b258:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
        the_node->color = RBT_RED;                                    
        iter_node->child[dir] = the_node;                             
4000b25c:	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;                                    
4000b260:	82 10 20 01 	mov  1, %g1                                    
        iter_node->child[dir] = the_node;                             
        the_node->parent = iter_node;                                 
4000b264:	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;                                    
4000b268:	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(                
4000b26c:	9f c0 80 00 	call  %g2                                      
4000b270:	90 10 00 19 	mov  %i1, %o0                                  
            the_node,                                                 
            _RBTree_First(the_rbtree, dir)                            
        );                                                            
        if ( (!dir && _RBTree_Is_lesser(compare_result)) ||           
4000b274:	80 a6 e0 00 	cmp  %i3, 0                                    
4000b278:	12 80 00 10 	bne  4000b2b8 <_RBTree_Insert_unprotected+0xe4>
4000b27c:	80 a2 20 00 	cmp  %o0, 0                                    
4000b280:	06 80 00 10 	bl  4000b2c0 <_RBTree_Insert_unprotected+0xec> 
4000b284:	b5 2e a0 02 	sll  %i2, 2, %i2                               
4000b288:	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;                                             
4000b28c:	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;                         
4000b290:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000b294:	86 90 a0 00 	orcc  %g2, 0, %g3                              
4000b298:	22 80 00 06 	be,a   4000b2b0 <_RBTree_Insert_unprotected+0xdc>
4000b29c:	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);                    
4000b2a0:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
4000b2a4:	80 a1 20 01 	cmp  %g4, 1                                    
4000b2a8:	22 80 00 08 	be,a   4000b2c8 <_RBTree_Insert_unprotected+0xf4>
4000b2ac:	f6 00 80 00 	ld  [ %g2 ], %i3                               
                                                                      
    /* verify red-black properties */                                 
    _RBTree_Validate_insert_unprotected(the_node);                    
  }                                                                   
  return (RBTree_Node*)0;                                             
}                                                                     
4000b2b0:	81 c7 e0 08 	ret                                            
4000b2b4:	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)) ) {         
4000b2b8:	04 bf ff f4 	ble  4000b288 <_RBTree_Insert_unprotected+0xb4>
4000b2bc:	b5 2e a0 02 	sll  %i2, 2, %i2                               
          the_rbtree->first[dir] = the_node;                          
4000b2c0:	10 bf ff f2 	b  4000b288 <_RBTree_Insert_unprotected+0xb4>  
4000b2c4:	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;                
4000b2c8:	80 a6 e0 00 	cmp  %i3, 0                                    
4000b2cc:	02 80 00 0c 	be  4000b2fc <_RBTree_Insert_unprotected+0x128><== NEVER TAKEN
4000b2d0:	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])                   
4000b2d4:	80 a1 00 01 	cmp  %g4, %g1                                  
4000b2d8:	02 80 00 5b 	be  4000b444 <_RBTree_Insert_unprotected+0x270>
4000b2dc:	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);                    
4000b2e0:	80 a7 60 00 	cmp  %i5, 0                                    
4000b2e4:	22 80 00 07 	be,a   4000b300 <_RBTree_Insert_unprotected+0x12c>
4000b2e8:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
4000b2ec:	f8 07 60 0c 	ld  [ %i5 + 0xc ], %i4                         
4000b2f0:	80 a7 20 01 	cmp  %i4, 1                                    
4000b2f4:	22 80 00 4f 	be,a   4000b430 <_RBTree_Insert_unprotected+0x25c>
4000b2f8:	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];  
4000b2fc:	fa 00 60 04 	ld  [ %g1 + 4 ], %i5                           
      RBTree_Direction pdir = the_node->parent != g->child[0];        
4000b300:	88 18 40 04 	xor  %g1, %g4, %g4                             
4000b304:	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];  
4000b308:	ba 1e 40 1d 	xor  %i1, %i5, %i5                             
      RBTree_Direction pdir = the_node->parent != g->child[0];        
4000b30c:	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];  
4000b310:	80 a0 00 1d 	cmp  %g0, %i5                                  
4000b314:	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) {                                              
4000b318:	80 a7 40 04 	cmp  %i5, %g4                                  
4000b31c:	02 80 00 20 	be  4000b39c <_RBTree_Insert_unprotected+0x1c8>
4000b320:	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);                         
4000b324:	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;
4000b328:	b7 2e e0 02 	sll  %i3, 2, %i3                               
4000b32c:	b6 00 40 1b 	add  %g1, %i3, %i3                             
4000b330:	fa 06 e0 04 	ld  [ %i3 + 4 ], %i5                           
4000b334:	80 a7 60 00 	cmp  %i5, 0                                    
4000b338:	02 80 00 16 	be  4000b390 <_RBTree_Insert_unprotected+0x1bc><== NEVER TAKEN
4000b33c:	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];   
4000b340:	9e 07 40 1c 	add  %i5, %i4, %o7                             
4000b344:	da 03 e0 04 	ld  [ %o7 + 4 ], %o5                           
4000b348:	da 26 e0 04 	st  %o5, [ %i3 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
4000b34c:	f6 03 e0 04 	ld  [ %o7 + 4 ], %i3                           
4000b350:	80 a6 e0 00 	cmp  %i3, 0                                    
4000b354:	22 80 00 05 	be,a   4000b368 <_RBTree_Insert_unprotected+0x194>
4000b358:	b6 07 40 1c 	add  %i5, %i4, %i3                             
    c->child[dir]->parent = the_node;                                 
4000b35c:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
4000b360:	c4 00 40 00 	ld  [ %g1 ], %g2                               
                                                                      
  c->child[dir] = the_node;                                           
4000b364:	b6 07 40 1c 	add  %i5, %i4, %i3                             
4000b368:	c2 26 e0 04 	st  %g1, [ %i3 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000b36c:	f6 00 a0 04 	ld  [ %g2 + 4 ], %i3                           
                                                                      
  c->parent = the_node->parent;                                       
4000b370:	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;
4000b374:	b6 1e c0 01 	xor  %i3, %g1, %i3                             
                                                                      
  c->parent = the_node->parent;                                       
  the_node->parent = c;                                               
4000b378:	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;
4000b37c:	80 a0 00 1b 	cmp  %g0, %i3                                  
4000b380:	82 40 20 00 	addx  %g0, 0, %g1                              
4000b384:	83 28 60 02 	sll  %g1, 2, %g1                               
4000b388:	84 00 80 01 	add  %g2, %g1, %g2                             
4000b38c:	fa 20 a0 04 	st  %i5, [ %g2 + 4 ]                           
        _RBTree_Rotate(the_node->parent, pdir);                       
        the_node = the_node->child[pdir];                             
4000b390:	b2 06 40 1c 	add  %i1, %i4, %i1                             
4000b394:	f2 06 60 04 	ld  [ %i1 + 4 ], %i1                           
4000b398:	c2 06 40 00 	ld  [ %i1 ], %g1                               
      }                                                               
      the_node->parent->color = RBT_BLACK;                            
4000b39c:	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));                                    
4000b3a0:	88 26 80 04 	sub  %i2, %g4, %g4                             
4000b3a4:	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;
4000b3a8:	bb 2f 60 02 	sll  %i5, 2, %i5                               
4000b3ac:	ba 00 c0 1d 	add  %g3, %i5, %i5                             
4000b3b0:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
4000b3b4:	80 a0 a0 00 	cmp  %g2, 0                                    
4000b3b8:	02 bf ff b6 	be  4000b290 <_RBTree_Insert_unprotected+0xbc> <== NEVER TAKEN
4000b3bc:	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];   
4000b3c0:	89 29 20 02 	sll  %g4, 2, %g4                               
4000b3c4:	82 00 80 04 	add  %g2, %g4, %g1                             
4000b3c8:	f8 00 60 04 	ld  [ %g1 + 4 ], %i4                           
4000b3cc:	f8 27 60 04 	st  %i4, [ %i5 + 4 ]                           
                                                                      
  if (c->child[dir])                                                  
4000b3d0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000b3d4:	80 a0 60 00 	cmp  %g1, 0                                    
4000b3d8:	32 80 00 02 	bne,a   4000b3e0 <_RBTree_Insert_unprotected+0x20c>
4000b3dc:	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;
4000b3e0:	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;                                           
4000b3e4:	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;                                       
4000b3e8:	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;                                           
4000b3ec:	c6 21 20 04 	st  %g3, [ %g4 + 4 ]                           
                                                                      
  the_node->parent->child[the_node != the_node->parent->child[0]] = c;
4000b3f0:	c8 07 60 04 	ld  [ %i5 + 4 ], %g4                           
                                                                      
  c->parent = the_node->parent;                                       
  the_node->parent = c;                                               
4000b3f4:	c4 20 c0 00 	st  %g2, [ %g3 ]                               
4000b3f8:	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;
4000b3fc:	86 18 c0 04 	xor  %g3, %g4, %g3                             
4000b400:	80 a0 00 03 	cmp  %g0, %g3                                  
4000b404:	86 40 20 00 	addx  %g0, 0, %g3                              
4000b408:	87 28 e0 02 	sll  %g3, 2, %g3                               
4000b40c:	ba 07 40 03 	add  %i5, %g3, %i5                             
4000b410:	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;                         
4000b414:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000b418:	86 90 a0 00 	orcc  %g2, 0, %g3                              
4000b41c:	32 bf ff a2 	bne,a   4000b2a4 <_RBTree_Insert_unprotected+0xd0><== ALWAYS TAKEN
4000b420:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
    }                                                                 
  }                                                                   
  if(!the_node->parent->parent) the_node->color = RBT_BLACK;          
4000b424:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             <== NOT EXECUTED
                                                                      
    /* verify red-black properties */                                 
    _RBTree_Validate_insert_unprotected(the_node);                    
  }                                                                   
  return (RBTree_Node*)0;                                             
}                                                                     
4000b428:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000b42c:	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;                                           
4000b430:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
      g->color = RBT_RED;                                             
4000b434:	f8 20 a0 0c 	st  %i4, [ %g2 + 0xc ]                         
4000b438:	82 10 00 1b 	mov  %i3, %g1                                  
4000b43c:	10 bf ff 95 	b  4000b290 <_RBTree_Insert_unprotected+0xbc>  
4000b440:	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];                        
4000b444:	10 bf ff a7 	b  4000b2e0 <_RBTree_Insert_unprotected+0x10c> 
4000b448:	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;                              
4000b44c:	81 c7 e0 08 	ret                                            
4000b450:	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 ) )
4000b454:	81 c7 e0 08 	ret                                            
4000b458:	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;                                      
4000b45c:	f2 26 20 04 	st  %i1, [ %i0 + 4 ]                           
    the_rbtree->first[0] = the_rbtree->first[1] = the_node;           
4000b460:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
4000b464:	f2 26 20 08 	st  %i1, [ %i0 + 8 ]                           
    the_node->parent = (RBTree_Node *) the_rbtree;                    
4000b468:	f0 26 40 00 	st  %i0, [ %i1 ]                               
    the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;    
4000b46c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
4000b470:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
    } /* while(iter_node) */                                          
                                                                      
    /* verify red-black properties */                                 
    _RBTree_Validate_insert_unprotected(the_node);                    
  }                                                                   
  return (RBTree_Node*)0;                                             
4000b474:	81 c7 e0 08 	ret                                            
4000b478:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000b4ac <_RBTree_Iterate_unprotected>: const RBTree_Control *rbtree, RBTree_Direction dir, RBTree_Visitor visitor, void *visitor_arg ) {
4000b4ac:	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);                         
4000b4b0:	80 a0 00 19 	cmp  %g0, %i1                                  
4000b4b4:	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];                                      
4000b4b8:	82 00 60 02 	add  %g1, 2, %g1                               
4000b4bc:	83 28 60 02 	sll  %g1, 2, %g1                               
4000b4c0:	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 ) {                                
4000b4c4:	80 a7 60 00 	cmp  %i5, 0                                    
4000b4c8:	12 80 00 06 	bne  4000b4e0 <_RBTree_Iterate_unprotected+0x34><== ALWAYS TAKEN
4000b4cc:	94 10 00 1b 	mov  %i3, %o2                                  
4000b4d0:	30 80 00 0e 	b,a   4000b508 <_RBTree_Iterate_unprotected+0x5c><== NOT EXECUTED
4000b4d4:	80 8f 20 ff 	btst  0xff, %i4                                
4000b4d8:	02 80 00 0c 	be  4000b508 <_RBTree_Iterate_unprotected+0x5c><== NEVER TAKEN
4000b4dc:	94 10 00 1b 	mov  %i3, %o2                                  
    stop = (*visitor)( current, dir, visitor_arg );                   
4000b4e0:	90 10 00 1d 	mov  %i5, %o0                                  
4000b4e4:	9f c6 80 00 	call  %i2                                      
4000b4e8:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
    current = _RBTree_Next_unprotected( current, dir );               
4000b4ec:	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 );                   
4000b4f0:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
    current = _RBTree_Next_unprotected( current, dir );               
4000b4f4:	40 00 00 07 	call  4000b510 <_RBTree_Next_unprotected>      
4000b4f8:	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 ) {                                
4000b4fc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000b500:	12 bf ff f5 	bne  4000b4d4 <_RBTree_Iterate_unprotected+0x28>
4000b504:	b8 1f 20 01 	xor  %i4, 1, %i4                               
4000b508:	81 c7 e0 08 	ret                                            
4000b50c:	81 e8 00 00 	restore                                        
                                                                      

40009618 <_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 ) {
40009618:	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 ];                
4000961c:	fa 06 21 4c 	ld  [ %i0 + 0x14c ], %i5                       
  if ( !api )                                                         
40009620:	80 a7 60 00 	cmp  %i5, 0                                    
40009624:	02 80 00 1e 	be  4000969c <_RTEMS_signal_Post_switch_hook+0x84><== NEVER TAKEN
40009628:	01 00 00 00 	nop                                            
   *  Signal Processing                                               
   */                                                                 
                                                                      
  asr = &api->Signal;                                                 
                                                                      
  _ISR_Disable( level );                                              
4000962c:	7f ff e7 52 	call  40003374 <sparc_disable_interrupts>      
40009630:	01 00 00 00 	nop                                            
    signal_set = asr->signals_posted;                                 
40009634:	f8 07 60 14 	ld  [ %i5 + 0x14 ], %i4                        
    asr->signals_posted = 0;                                          
40009638:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            
  _ISR_Enable( level );                                               
4000963c:	7f ff e7 52 	call  40003384 <sparc_enable_interrupts>       
40009640:	01 00 00 00 	nop                                            
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
40009644:	80 a7 20 00 	cmp  %i4, 0                                    
40009648:	32 80 00 04 	bne,a   40009658 <_RTEMS_signal_Post_switch_hook+0x40>
4000964c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
40009650:	81 c7 e0 08 	ret                                            
40009654:	81 e8 00 00 	restore                                        
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
40009658:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
4000965c:	82 00 60 01 	inc  %g1                                       
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
40009660:	94 07 bf fc 	add  %fp, -4, %o2                              
40009664:	37 00 00 3f 	sethi  %hi(0xfc00), %i3                        
                                                                      
                                                                      
  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 
    return;                                                           
                                                                      
  asr->nest_level += 1;                                               
40009668:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 
4000966c:	40 00 01 07 	call  40009a88 <rtems_task_mode>               
40009670:	92 16 e3 ff 	or  %i3, 0x3ff, %o1                            
                                                                      
  (*asr->handler)( signal_set );                                      
40009674:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
40009678:	9f c0 40 00 	call  %g1                                      
4000967c:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  asr->nest_level -= 1;                                               
40009680:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
40009684:	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;                                               
40009688:	82 00 7f ff 	add  %g1, -1, %g1                              
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );     
4000968c:	92 16 e3 ff 	or  %i3, 0x3ff, %o1                            
40009690:	94 07 bf fc 	add  %fp, -4, %o2                              
40009694:	40 00 00 fd 	call  40009a88 <rtems_task_mode>               
40009698:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
4000969c:	81 c7 e0 08 	ret                                            
400096a0:	81 e8 00 00 	restore                                        
                                                                      

400089cc <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) {
400089cc:	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;
400089d0:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
400089d4:	82 10 60 e4 	or  %g1, 0xe4, %g1	! 4001f4e4 <Configuration_RTEMS_API>
400089d8:	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 )                                                  
400089dc:	80 a7 60 00 	cmp  %i5, 0                                    
400089e0:	02 80 00 18 	be  40008a40 <_RTEMS_tasks_Initialize_user_tasks_body+0x74>
400089e4:	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++ ) {                       
400089e8:	80 a6 e0 00 	cmp  %i3, 0                                    
400089ec:	02 80 00 15 	be  40008a40 <_RTEMS_tasks_Initialize_user_tasks_body+0x74><== NEVER TAKEN
400089f0:	b8 10 20 00 	clr  %i4                                       
    return_value = rtems_task_create(                                 
400089f4:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
400089f8:	d0 07 40 00 	ld  [ %i5 ], %o0                               
400089fc:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
40008a00:	d6 07 60 14 	ld  [ %i5 + 0x14 ], %o3                        
40008a04:	d8 07 60 0c 	ld  [ %i5 + 0xc ], %o4                         
40008a08:	7f ff ff 70 	call  400087c8 <rtems_task_create>             
40008a0c:	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 ) )                
40008a10:	94 92 20 00 	orcc  %o0, 0, %o2                              
40008a14:	12 80 00 0d 	bne  40008a48 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
40008a18:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
                                                                      
    return_value = rtems_task_start(                                  
40008a1c:	d4 07 60 18 	ld  [ %i5 + 0x18 ], %o2                        
40008a20:	40 00 00 0e 	call  40008a58 <rtems_task_start>              
40008a24:	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 ) )                
40008a28:	94 92 20 00 	orcc  %o0, 0, %o2                              
40008a2c:	12 80 00 07 	bne  40008a48 <_RTEMS_tasks_Initialize_user_tasks_body+0x7c>
40008a30:	b8 07 20 01 	inc  %i4                                       
    return;                                                           
                                                                      
  /*                                                                  
   *  Now iterate over the initialization tasks and create/start them.
   */                                                                 
  for ( index=0 ; index < maximum ; index++ ) {                       
40008a34:	80 a7 00 1b 	cmp  %i4, %i3                                  
40008a38:	12 bf ff ef 	bne  400089f4 <_RTEMS_tasks_Initialize_user_tasks_body+0x28><== NEVER TAKEN
40008a3c:	ba 07 60 1c 	add  %i5, 0x1c, %i5                            
40008a40:	81 c7 e0 08 	ret                                            
40008a44:	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 );
40008a48:	90 10 20 01 	mov  1, %o0                                    
40008a4c:	40 00 04 30 	call  40009b0c <_Internal_error_Occurred>      
40008a50:	92 10 20 01 	mov  1, %o1                                    
                                                                      

4000e2e0 <_RTEMS_tasks_Switch_extension>: /* * Per Task Variables */ tvp = executing->task_variables;
4000e2e0:	c2 02 21 58 	ld  [ %o0 + 0x158 ], %g1                       
  while (tvp) {                                                       
4000e2e4:	80 a0 60 00 	cmp  %g1, 0                                    
4000e2e8:	22 80 00 0c 	be,a   4000e318 <_RTEMS_tasks_Switch_extension+0x38>
4000e2ec:	c2 02 61 58 	ld  [ %o1 + 0x158 ], %g1                       
    tvp->tval = *tvp->ptr;                                            
4000e2f0:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
    *tvp->ptr = tvp->gval;                                            
4000e2f4:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
   *  Per Task Variables                                              
   */                                                                 
                                                                      
  tvp = executing->task_variables;                                    
  while (tvp) {                                                       
    tvp->tval = *tvp->ptr;                                            
4000e2f8:	c8 00 80 00 	ld  [ %g2 ], %g4                               
4000e2fc:	c8 20 60 0c 	st  %g4, [ %g1 + 0xc ]                         
    *tvp->ptr = tvp->gval;                                            
4000e300:	c6 20 80 00 	st  %g3, [ %g2 ]                               
    tvp = (rtems_task_variable_t *)tvp->next;                         
4000e304:	c2 00 40 00 	ld  [ %g1 ], %g1                               
  /*                                                                  
   *  Per Task Variables                                              
   */                                                                 
                                                                      
  tvp = executing->task_variables;                                    
  while (tvp) {                                                       
4000e308:	80 a0 60 00 	cmp  %g1, 0                                    
4000e30c:	32 bf ff fa 	bne,a   4000e2f4 <_RTEMS_tasks_Switch_extension+0x14><== NEVER TAKEN
4000e310:	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;                                         
4000e314:	c2 02 61 58 	ld  [ %o1 + 0x158 ], %g1                       
  while (tvp) {                                                       
4000e318:	80 a0 60 00 	cmp  %g1, 0                                    
4000e31c:	02 80 00 0d 	be  4000e350 <_RTEMS_tasks_Switch_extension+0x70>
4000e320:	01 00 00 00 	nop                                            
    tvp->gval = *tvp->ptr;                                            
4000e324:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
    *tvp->ptr = tvp->tval;                                            
4000e328:	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;                                            
4000e32c:	c8 00 80 00 	ld  [ %g2 ], %g4                               
4000e330:	c8 20 60 08 	st  %g4, [ %g1 + 8 ]                           
    *tvp->ptr = tvp->tval;                                            
4000e334:	c6 20 80 00 	st  %g3, [ %g2 ]                               
    tvp = (rtems_task_variable_t *)tvp->next;                         
4000e338:	c2 00 40 00 	ld  [ %g1 ], %g1                               
    *tvp->ptr = tvp->gval;                                            
    tvp = (rtems_task_variable_t *)tvp->next;                         
  }                                                                   
                                                                      
  tvp = heir->task_variables;                                         
  while (tvp) {                                                       
4000e33c:	80 a0 60 00 	cmp  %g1, 0                                    
4000e340:	32 bf ff fa 	bne,a   4000e328 <_RTEMS_tasks_Switch_extension+0x48><== NEVER TAKEN
4000e344:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           <== NOT EXECUTED
4000e348:	81 c3 e0 08 	retl                                           
4000e34c:	01 00 00 00 	nop                                            
4000e350:	81 c3 e0 08 	retl                                           
                                                                      

4003888c <_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 ) {
4003888c:	9d e3 bf 98 	save  %sp, -104, %sp                           
 */                                                                   
static inline void _TOD_Get_uptime(                                   
  Timestamp_Control *time                                             
)                                                                     
{                                                                     
  _TOD_Get_with_nanoseconds( time, &_TOD.uptime );                    
40038890:	13 10 01 a5 	sethi  %hi(0x40069400), %o1                    
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    Timestamp_Control        uptime;                                  
  #endif                                                              
    Thread_Control          *owning_thread = the_period->owner;       
40038894:	f6 06 20 40 	ld  [ %i0 + 0x40 ], %i3                        
40038898:	90 07 bf f8 	add  %fp, -8, %o0                              
4003889c:	7f ff 41 e1 	call  40009020 <_TOD_Get_with_nanoseconds>     
400388a0:	92 12 63 e0 	or  %o1, 0x3e0, %o1                            
  /*                                                                  
   *  Determine elapsed wall time since period initiated.             
   */                                                                 
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    _TOD_Get_uptime( &uptime );                                       
    _Timestamp_Subtract(                                              
400388a4:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
400388a8:	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) {                         
400388ac:	03 10 01 a7 	sethi  %hi(0x40069c00), %g1                    
400388b0:	82 10 61 a0 	or  %g1, 0x1a0, %g1	! 40069da0 <_Per_CPU_Information>
400388b4:	de 00 60 10 	ld  [ %g1 + 0x10 ], %o7                        
400388b8:	ba a0 c0 1d 	subcc  %g3, %i5, %i5                           
400388bc:	b8 60 80 1c 	subx  %g2, %i4, %i4                            
400388c0:	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;                                                        
400388c4:	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) {                         
400388c8:	80 a3 c0 1b 	cmp  %o7, %i3                                  
400388cc:	02 80 00 05 	be  400388e0 <_Rate_monotonic_Get_status+0x54> 
400388d0:	f8 1e e0 80 	ldd  [ %i3 + 0x80 ], %i4                       
        return false;                                                 
                                                                      
      *cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
  #endif                                                              
  return true;                                                        
}                                                                     
400388d4:	b0 09 20 01 	and  %g4, 1, %i0                               
400388d8:	81 c7 e0 08 	ret                                            
400388dc:	81 e8 00 00 	restore                                        
400388e0:	d8 18 60 20 	ldd  [ %g1 + 0x20 ], %o4                       
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400388e4:	f0 1e 20 48 	ldd  [ %i0 + 0x48 ], %i0                       
400388e8:	86 a0 c0 0d 	subcc  %g3, %o5, %g3                           
400388ec:	84 60 80 0c 	subx  %g2, %o4, %g2                            
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
400388f0:	9a 87 40 03 	addcc  %i5, %g3, %o5                           
400388f4:	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))
400388f8:	80 a6 00 0c 	cmp  %i0, %o4                                  
400388fc:	14 bf ff f6 	bg  400388d4 <_Rate_monotonic_Get_status+0x48> <== NEVER TAKEN
40038900:	88 10 20 00 	clr  %g4                                       
40038904:	02 80 00 09 	be  40038928 <_Rate_monotonic_Get_status+0x9c> 
40038908:	80 a6 40 0d 	cmp  %i1, %o5                                  
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
4003890c:	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;                                                        
40038910:	88 10 20 01 	mov  1, %g4                                    
40038914:	98 63 00 18 	subx  %o4, %i0, %o4                            
}                                                                     
40038918:	b0 09 20 01 	and  %g4, 1, %i0                               
4003891c:	d8 3e 80 00 	std  %o4, [ %i2 ]                              
40038920:	81 c7 e0 08 	ret                                            
40038924:	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))
40038928:	28 bf ff fa 	bleu,a   40038910 <_Rate_monotonic_Get_status+0x84>
4003892c:	9a a3 40 19 	subcc  %o5, %i1, %o5                           
        return false;                                                 
40038930:	10 bf ff e9 	b  400388d4 <_Rate_monotonic_Get_status+0x48>  
40038934:	88 10 20 00 	clr  %g4                                       
                                                                      

40038cdc <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) {
40038cdc:	9d e3 bf 98 	save  %sp, -104, %sp                           
40038ce0:	11 10 01 a8 	sethi  %hi(0x4006a000), %o0                    
40038ce4:	92 10 00 18 	mov  %i0, %o1                                  
40038ce8:	90 12 23 68 	or  %o0, 0x368, %o0                            
40038cec:	7f ff 43 a1 	call  40009b70 <_Objects_Get>                  
40038cf0:	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 ) {                                               
40038cf4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40038cf8:	80 a0 60 00 	cmp  %g1, 0                                    
40038cfc:	12 80 00 16 	bne  40038d54 <_Rate_monotonic_Timeout+0x78>   <== NEVER TAKEN
40038d00:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      the_thread = the_period->owner;                                 
40038d04:	d0 02 20 40 	ld  [ %o0 + 0x40 ], %o0                        
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
40038d08:	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);                   
40038d0c:	c4 02 20 10 	ld  [ %o0 + 0x10 ], %g2                        
40038d10:	80 88 80 01 	btst  %g2, %g1                                 
40038d14:	22 80 00 08 	be,a   40038d34 <_Rate_monotonic_Timeout+0x58> 
40038d18:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
40038d1c:	c4 02 20 20 	ld  [ %o0 + 0x20 ], %g2                        
40038d20:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40038d24:	80 a0 80 01 	cmp  %g2, %g1                                  
40038d28:	02 80 00 19 	be  40038d8c <_Rate_monotonic_Timeout+0xb0>    
40038d2c:	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 ) {
40038d30:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
40038d34:	80 a0 60 01 	cmp  %g1, 1                                    
40038d38:	02 80 00 09 	be  40038d5c <_Rate_monotonic_Timeout+0x80>    
40038d3c:	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;                   
40038d40:	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;                  
40038d44:	03 10 01 a6 	sethi  %hi(0x40069800), %g1                    
40038d48:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2	! 40069890 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
40038d4c:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
40038d50:	c4 20 60 90 	st  %g2, [ %g1 + 0x90 ]                        
40038d54:	81 c7 e0 08 	ret                                            
40038d58:	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;    
40038d5c:	82 10 20 03 	mov  3, %g1                                    
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
40038d60:	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;    
40038d64:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
                                                                      
        _Rate_monotonic_Initiate_statistics( the_period );            
40038d68:	7f ff ff 43 	call  40038a74 <_Rate_monotonic_Initiate_statistics>
40038d6c:	01 00 00 00 	nop                                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40038d70:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40038d74:	11 10 01 a6 	sethi  %hi(0x40069800), %o0                    
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40038d78:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40038d7c:	90 12 21 28 	or  %o0, 0x128, %o0                            
40038d80:	7f ff 4a 6f 	call  4000b73c <_Watchdog_Insert>              
40038d84:	92 07 60 10 	add  %i5, 0x10, %o1                            
40038d88:	30 bf ff ef 	b,a   40038d44 <_Rate_monotonic_Timeout+0x68>  
                                                                      
RTEMS_INLINE_ROUTINE void _Thread_Unblock (                           
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  _Thread_Clear_state( the_thread, STATES_BLOCKED );                  
40038d8c:	7f ff 46 43 	call  4000a698 <_Thread_Clear_state>           
40038d90:	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 );            
40038d94:	10 bf ff f5 	b  40038d68 <_Rate_monotonic_Timeout+0x8c>     
40038d98:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      

40038938 <_Rate_monotonic_Update_statistics>: } static void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) {
40038938:	9d e3 bf 90 	save  %sp, -112, %sp                           
                                                                      
  /*                                                                  
   *  Update the counts.                                              
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
4003893c:	c4 06 20 58 	ld  [ %i0 + 0x58 ], %g2                        
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
40038940:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
                                                                      
  /*                                                                  
   *  Update the counts.                                              
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
40038944:	84 00 a0 01 	inc  %g2                                       
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
40038948:	80 a0 60 04 	cmp  %g1, 4                                    
4003894c:	02 80 00 32 	be  40038a14 <_Rate_monotonic_Update_statistics+0xdc>
40038950:	c4 26 20 58 	st  %g2, [ %i0 + 0x58 ]                        
    stats->missed_count++;                                            
                                                                      
  /*                                                                  
   *  Grab status for time statistics.                                
   */                                                                 
  valid_status =                                                      
40038954:	90 10 00 18 	mov  %i0, %o0                                  
40038958:	92 07 bf f8 	add  %fp, -8, %o1                              
4003895c:	7f ff ff cc 	call  4003888c <_Rate_monotonic_Get_status>    
40038960:	94 07 bf f0 	add  %fp, -16, %o2                             
    _Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
  if (!valid_status)                                                  
40038964:	80 8a 20 ff 	btst  0xff, %o0                                
40038968:	02 80 00 21 	be  400389ec <_Rate_monotonic_Update_statistics+0xb4>
4003896c:	c4 1f bf f0 	ldd  [ %fp + -16 ], %g2                        
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
40038970:	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 ) )    
40038974:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
40038978:	b6 87 40 03 	addcc  %i5, %g3, %i3                           
4003897c:	b4 47 00 02 	addx  %i4, %g2, %i2                            
40038980:	80 a0 40 02 	cmp  %g1, %g2                                  
40038984:	04 80 00 1c 	ble  400389f4 <_Rate_monotonic_Update_statistics+0xbc>
40038988:	f4 3e 20 70 	std  %i2, [ %i0 + 0x70 ]                       
      stats->min_cpu_time = executed;                                 
4003898c:	c4 3e 20 60 	std  %g2, [ %i0 + 0x60 ]                       
                                                                      
    if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 
40038990:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        
40038994:	80 a0 40 02 	cmp  %g1, %g2                                  
40038998:	26 80 00 05 	bl,a   400389ac <_Rate_monotonic_Update_statistics+0x74><== NEVER TAKEN
4003899c:	c4 3e 20 68 	std  %g2, [ %i0 + 0x68 ]                       <== NOT EXECUTED
400389a0:	80 a0 40 02 	cmp  %g1, %g2                                  
400389a4:	22 80 00 28 	be,a   40038a44 <_Rate_monotonic_Update_statistics+0x10c><== ALWAYS TAKEN
400389a8:	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 ); 
400389ac:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
400389b0:	f8 1e 20 88 	ldd  [ %i0 + 0x88 ], %i4                       
                                                                      
    if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
400389b4:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
400389b8:	b6 87 40 03 	addcc  %i5, %g3, %i3                           
400389bc:	b4 47 00 02 	addx  %i4, %g2, %i2                            
400389c0:	80 a0 40 02 	cmp  %g1, %g2                                  
400389c4:	14 80 00 1b 	bg  40038a30 <_Rate_monotonic_Update_statistics+0xf8>
400389c8:	f4 3e 20 88 	std  %i2, [ %i0 + 0x88 ]                       
400389cc:	80 a0 40 02 	cmp  %g1, %g2                                  
400389d0:	22 80 00 15 	be,a   40038a24 <_Rate_monotonic_Update_statistics+0xec><== ALWAYS TAKEN
400389d4:	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 ) )
400389d8:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
400389dc:	80 a0 40 02 	cmp  %g1, %g2                                  
400389e0:	16 80 00 1e 	bge  40038a58 <_Rate_monotonic_Update_statistics+0x120><== ALWAYS TAKEN
400389e4:	01 00 00 00 	nop                                            
      stats->max_wall_time = since_last_period;                       
400389e8:	c4 3e 20 80 	std  %g2, [ %i0 + 0x80 ]                       <== NOT EXECUTED
400389ec:	81 c7 e0 08 	ret                                            
400389f0:	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 ) )    
400389f4:	32 bf ff e8 	bne,a   40038994 <_Rate_monotonic_Update_statistics+0x5c><== NEVER TAKEN
400389f8:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        <== NOT EXECUTED
400389fc:	c2 06 20 64 	ld  [ %i0 + 0x64 ], %g1                        
40038a00:	80 a0 40 03 	cmp  %g1, %g3                                  
40038a04:	28 bf ff e4 	bleu,a   40038994 <_Rate_monotonic_Update_statistics+0x5c>
40038a08:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        
      stats->min_cpu_time = executed;                                 
40038a0c:	10 bf ff e1 	b  40038990 <_Rate_monotonic_Update_statistics+0x58>
40038a10:	c4 3e 20 60 	std  %g2, [ %i0 + 0x60 ]                       
   */                                                                 
  stats = &the_period->Statistics;                                    
  stats->count++;                                                     
                                                                      
  if ( the_period->state == RATE_MONOTONIC_EXPIRED )                  
    stats->missed_count++;                                            
40038a14:	c2 06 20 5c 	ld  [ %i0 + 0x5c ], %g1                        
40038a18:	82 00 60 01 	inc  %g1                                       
40038a1c:	10 bf ff ce 	b  40038954 <_Rate_monotonic_Update_statistics+0x1c>
40038a20:	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 ) )
40038a24:	80 a0 40 03 	cmp  %g1, %g3                                  
40038a28:	28 bf ff ed 	bleu,a   400389dc <_Rate_monotonic_Update_statistics+0xa4>
40038a2c:	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 ) )
40038a30:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        
40038a34:	80 a0 40 02 	cmp  %g1, %g2                                  
40038a38:	06 bf ff ec 	bl  400389e8 <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
40038a3c:	c4 3e 20 78 	std  %g2, [ %i0 + 0x78 ]                       
40038a40:	30 80 00 06 	b,a   40038a58 <_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 ) ) 
40038a44:	80 a0 40 03 	cmp  %g1, %g3                                  
40038a48:	3a bf ff da 	bcc,a   400389b0 <_Rate_monotonic_Update_statistics+0x78>
40038a4c:	c4 1f bf f8 	ldd  [ %fp + -8 ], %g2                         
      stats->max_cpu_time = executed;                                 
40038a50:	10 bf ff d7 	b  400389ac <_Rate_monotonic_Update_statistics+0x74>
40038a54:	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 ) )
40038a58:	12 bf ff e5 	bne  400389ec <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
40038a5c:	01 00 00 00 	nop                                            
40038a60:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
40038a64:	80 a0 40 03 	cmp  %g1, %g3                                  
40038a68:	2a bf ff e1 	bcs,a   400389ec <_Rate_monotonic_Update_statistics+0xb4>
40038a6c:	c4 3e 20 80 	std  %g2, [ %i0 + 0x80 ]                       
40038a70:	30 bf ff df 	b,a   400389ec <_Rate_monotonic_Update_statistics+0xb4>
                                                                      

4000afbc <_Scheduler_CBS_Allocate>: #include <rtems/score/wkspace.h> void *_Scheduler_CBS_Allocate( Thread_Control *the_thread ) {
4000afbc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *sched;                                                        
  Scheduler_CBS_Per_thread *schinfo;                                  
                                                                      
  sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));      
4000afc0:	40 00 07 11 	call  4000cc04 <_Workspace_Allocate>           
4000afc4:	90 10 20 1c 	mov  0x1c, %o0                                 
  if ( sched ) {                                                      
4000afc8:	80 a2 20 00 	cmp  %o0, 0                                    
4000afcc:	02 80 00 06 	be  4000afe4 <_Scheduler_CBS_Allocate+0x28>    <== NEVER TAKEN
4000afd0:	82 10 20 02 	mov  2, %g1                                    
    the_thread->scheduler_info = sched;                               
4000afd4:	d0 26 20 88 	st  %o0, [ %i0 + 0x88 ]                        
    schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
    schinfo->edf_per_thread.thread = the_thread;                      
4000afd8:	f0 22 00 00 	st  %i0, [ %o0 ]                               
    schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
4000afdc:	c2 22 20 14 	st  %g1, [ %o0 + 0x14 ]                        
    schinfo->cbs_server = NULL;                                       
4000afe0:	c0 22 20 18 	clr  [ %o0 + 0x18 ]                            
  }                                                                   
                                                                      
  return sched;                                                       
}                                                                     
4000afe4:	81 c7 e0 08 	ret                                            
4000afe8:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

4000c390 <_Scheduler_CBS_Budget_callout>: Scheduler_CBS_Server **_Scheduler_CBS_Server_list; void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) {
4000c390:	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;                  
4000c394:	d2 06 20 ac 	ld  [ %i0 + 0xac ], %o1                        
  if ( the_thread->real_priority != new_priority )                    
4000c398:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
4000c39c:	80 a0 40 09 	cmp  %g1, %o1                                  
4000c3a0:	32 80 00 02 	bne,a   4000c3a8 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
4000c3a4:	d2 26 20 18 	st  %o1, [ %i0 + 0x18 ]                        
    the_thread->real_priority = new_priority;                         
  if ( the_thread->current_priority != new_priority )                 
4000c3a8:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4000c3ac:	80 a0 40 09 	cmp  %g1, %o1                                  
4000c3b0:	02 80 00 04 	be  4000c3c0 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
4000c3b4:	90 10 00 18 	mov  %i0, %o0                                  
    _Thread_Change_priority(the_thread, new_priority, true);          
4000c3b8:	40 00 01 92 	call  4000ca00 <_Thread_Change_priority>       
4000c3bc:	94 10 20 01 	mov  1, %o2                                    
                                                                      
  /* Invoke callback function if any. */                              
  sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
4000c3c0:	fa 06 20 88 	ld  [ %i0 + 0x88 ], %i5                        
  if ( sched_info->cbs_server->cbs_budget_overrun ) {                 
4000c3c4:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
4000c3c8:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000c3cc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c3d0:	02 80 00 09 	be  4000c3f4 <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
4000c3d4:	01 00 00 00 	nop                                            
    _Scheduler_CBS_Get_server_id(                                     
4000c3d8:	d0 00 40 00 	ld  [ %g1 ], %o0                               
4000c3dc:	7f ff ff d5 	call  4000c330 <_Scheduler_CBS_Get_server_id>  
4000c3e0:	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 );          
4000c3e4:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
4000c3e8:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4000c3ec:	9f c0 40 00 	call  %g1                                      
4000c3f0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
4000c3f4:	81 c7 e0 08 	ret                                            
4000c3f8:	81 e8 00 00 	restore                                        
                                                                      

4000bee8 <_Scheduler_CBS_Cleanup>: #include <rtems/config.h> #include <rtems/score/scheduler.h> #include <rtems/score/schedulercbs.h> int _Scheduler_CBS_Cleanup (void) {
4000bee8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  unsigned int i;                                                     
                                                                      
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
4000beec:	39 10 00 8b 	sethi  %hi(0x40022c00), %i4                    
4000bef0:	c2 07 21 20 	ld  [ %i4 + 0x120 ], %g1	! 40022d20 <_Scheduler_CBS_Maximum_servers>
4000bef4:	80 a0 60 00 	cmp  %g1, 0                                    
4000bef8:	02 80 00 18 	be  4000bf58 <_Scheduler_CBS_Cleanup+0x70>     <== NEVER TAKEN
4000befc:	03 10 00 90 	sethi  %hi(0x40024000), %g1                    
4000bf00:	37 10 00 90 	sethi  %hi(0x40024000), %i3                    
4000bf04:	c4 06 e0 28 	ld  [ %i3 + 0x28 ], %g2	! 40024028 <_Scheduler_CBS_Server_list>
4000bf08:	ba 10 20 00 	clr  %i5                                       
4000bf0c:	b8 17 21 20 	or  %i4, 0x120, %i4                            
    if ( _Scheduler_CBS_Server_list[ i ] )                            
4000bf10:	83 2f 60 02 	sll  %i5, 2, %g1                               
4000bf14:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
4000bf18:	80 a0 60 00 	cmp  %g1, 0                                    
4000bf1c:	02 80 00 05 	be  4000bf30 <_Scheduler_CBS_Cleanup+0x48>     
4000bf20:	90 10 00 1d 	mov  %i5, %o0                                  
      _Scheduler_CBS_Destroy_server( i );                             
4000bf24:	40 00 00 46 	call  4000c03c <_Scheduler_CBS_Destroy_server> 
4000bf28:	01 00 00 00 	nop                                            
4000bf2c:	c4 06 e0 28 	ld  [ %i3 + 0x28 ], %g2                        
                                                                      
int _Scheduler_CBS_Cleanup (void)                                     
{                                                                     
  unsigned int i;                                                     
                                                                      
  for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {              
4000bf30:	c2 07 00 00 	ld  [ %i4 ], %g1                               
4000bf34:	ba 07 60 01 	inc  %i5                                       
4000bf38:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000bf3c:	18 bf ff f6 	bgu  4000bf14 <_Scheduler_CBS_Cleanup+0x2c>    
4000bf40:	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;                                            
}                                                                     
4000bf44:	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 );                      
4000bf48:	40 00 08 41 	call  4000e04c <_Workspace_Free>               
4000bf4c:	90 10 00 02 	mov  %g2, %o0                                  
  return SCHEDULER_CBS_OK;                                            
}                                                                     
4000bf50:	81 c7 e0 08 	ret                                            
4000bf54:	81 e8 00 00 	restore                                        
4000bf58:	10 bf ff fb 	b  4000bf44 <_Scheduler_CBS_Cleanup+0x5c>      <== NOT EXECUTED
4000bf5c:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2                        <== NOT EXECUTED
                                                                      

4000bf60 <_Scheduler_CBS_Create_server>: int _Scheduler_CBS_Create_server ( Scheduler_CBS_Parameters *params, Scheduler_CBS_Budget_overrun budget_overrun_callback, rtems_id *server_id ) {
4000bf60:	9d e3 bf a0 	save  %sp, -96, %sp                            
  unsigned int i;                                                     
  Scheduler_CBS_Server *the_server;                                   
                                                                      
  if ( params->budget <= 0 ||                                         
4000bf64:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000bf68:	80 a0 60 00 	cmp  %g1, 0                                    
4000bf6c:	04 80 00 30 	ble  4000c02c <_Scheduler_CBS_Create_server+0xcc>
4000bf70:	b8 10 00 18 	mov  %i0, %i4                                  
4000bf74:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000bf78:	80 a0 60 00 	cmp  %g1, 0                                    
4000bf7c:	04 80 00 2c 	ble  4000c02c <_Scheduler_CBS_Create_server+0xcc>
4000bf80:	03 10 00 8b 	sethi  %hi(0x40022c00), %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++ ) {              
4000bf84:	c8 00 61 20 	ld  [ %g1 + 0x120 ], %g4	! 40022d20 <_Scheduler_CBS_Maximum_servers>
4000bf88:	80 a1 20 00 	cmp  %g4, 0                                    
4000bf8c:	02 80 00 11 	be  4000bfd0 <_Scheduler_CBS_Create_server+0x70><== NEVER TAKEN
4000bf90:	37 10 00 90 	sethi  %hi(0x40024000), %i3                    
    if ( !_Scheduler_CBS_Server_list[i] )                             
4000bf94:	fa 06 e0 28 	ld  [ %i3 + 0x28 ], %i5	! 40024028 <_Scheduler_CBS_Server_list>
4000bf98:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4000bf9c:	80 a0 60 00 	cmp  %g1, 0                                    
4000bfa0:	02 80 00 21 	be  4000c024 <_Scheduler_CBS_Create_server+0xc4>
4000bfa4:	b0 10 20 00 	clr  %i0                                       
4000bfa8:	10 80 00 06 	b  4000bfc0 <_Scheduler_CBS_Create_server+0x60>
4000bfac:	82 10 20 00 	clr  %g1                                       
4000bfb0:	c6 07 40 02 	ld  [ %i5 + %g2 ], %g3                         
4000bfb4:	80 a0 e0 00 	cmp  %g3, 0                                    
4000bfb8:	02 80 00 08 	be  4000bfd8 <_Scheduler_CBS_Create_server+0x78>
4000bfbc:	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++ ) {              
4000bfc0:	82 00 60 01 	inc  %g1                                       
4000bfc4:	80 a0 40 04 	cmp  %g1, %g4                                  
4000bfc8:	12 bf ff fa 	bne  4000bfb0 <_Scheduler_CBS_Create_server+0x50>
4000bfcc:	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;                                  
4000bfd0:	81 c7 e0 08 	ret                                            
4000bfd4:	91 e8 3f e6 	restore  %g0, -26, %o0                         
                                                                      
  *server_id = i;                                                     
4000bfd8:	c2 26 80 00 	st  %g1, [ %i2 ]                               
  _Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)   
    _Workspace_Allocate( sizeof(Scheduler_CBS_Server) );              
4000bfdc:	40 00 08 14 	call  4000e02c <_Workspace_Allocate>           
4000bfe0:	90 10 20 10 	mov  0x10, %o0                                 
  the_server = _Scheduler_CBS_Server_list[*server_id];                
4000bfe4:	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 *)   
4000bfe8:	d0 27 40 18 	st  %o0, [ %i5 + %i0 ]                         
    _Workspace_Allocate( sizeof(Scheduler_CBS_Server) );              
  the_server = _Scheduler_CBS_Server_list[*server_id];                
4000bfec:	c4 06 e0 28 	ld  [ %i3 + 0x28 ], %g2                        
4000bff0:	83 28 60 02 	sll  %g1, 2, %g1                               
4000bff4:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
  if ( !the_server )                                                  
4000bff8:	80 a0 60 00 	cmp  %g1, 0                                    
4000bffc:	02 80 00 0e 	be  4000c034 <_Scheduler_CBS_Create_server+0xd4><== NEVER TAKEN
4000c000:	86 10 3f ff 	mov  -1, %g3                                   
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
                                                                      
  the_server->parameters = *params;                                   
4000c004:	c4 07 00 00 	ld  [ %i4 ], %g2                               
4000c008:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
4000c00c:	c4 07 20 04 	ld  [ %i4 + 4 ], %g2                           
  the_server->task_id = -1;                                           
4000c010:	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;                                   
4000c014:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
  the_server->task_id = -1;                                           
  the_server->cbs_budget_overrun = budget_overrun_callback;           
4000c018:	f2 20 60 0c 	st  %i1, [ %g1 + 0xc ]                         
  return SCHEDULER_CBS_OK;                                            
4000c01c:	81 c7 e0 08 	ret                                            
4000c020:	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] )                             
4000c024:	10 bf ff ed 	b  4000bfd8 <_Scheduler_CBS_Create_server+0x78>
4000c028:	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;                     
4000c02c:	81 c7 e0 08 	ret                                            
4000c030:	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;                                            
}                                                                     
4000c034:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000c038:	91 e8 3f ef 	restore  %g0, -17, %o0                         <== NOT EXECUTED
                                                                      

4000c0bc <_Scheduler_CBS_Detach_thread>: int _Scheduler_CBS_Detach_thread ( Scheduler_CBS_Server_id server_id, rtems_id task_id ) {
4000c0bc:	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);                       
4000c0c0:	92 07 bf fc 	add  %fp, -4, %o1                              
4000c0c4:	40 00 03 95 	call  4000cf18 <_Thread_Get>                   
4000c0c8:	90 10 00 19 	mov  %i1, %o0                                  
  /* The routine _Thread_Get may disable dispatch and not enable again. */
  if ( the_thread ) {                                                 
4000c0cc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000c0d0:	02 80 00 1e 	be  4000c148 <_Scheduler_CBS_Detach_thread+0x8c>
4000c0d4:	01 00 00 00 	nop                                            
    _Thread_Enable_dispatch();                                        
4000c0d8:	40 00 03 84 	call  4000cee8 <_Thread_Enable_dispatch>       
4000c0dc:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  if ( server_id >= _Scheduler_CBS_Maximum_servers )                  
4000c0e0:	03 10 00 8b 	sethi  %hi(0x40022c00), %g1                    
4000c0e4:	c2 00 61 20 	ld  [ %g1 + 0x120 ], %g1	! 40022d20 <_Scheduler_CBS_Maximum_servers>
4000c0e8:	80 a6 00 01 	cmp  %i0, %g1                                  
4000c0ec:	1a 80 00 17 	bcc  4000c148 <_Scheduler_CBS_Detach_thread+0x8c>
4000c0f0:	03 10 00 90 	sethi  %hi(0x40024000), %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] )                       
4000c0f4:	c2 00 60 28 	ld  [ %g1 + 0x28 ], %g1	! 40024028 <_Scheduler_CBS_Server_list>
4000c0f8:	b1 2e 20 02 	sll  %i0, 2, %i0                               
4000c0fc:	c2 00 40 18 	ld  [ %g1 + %i0 ], %g1                         
4000c100:	80 a0 60 00 	cmp  %g1, 0                                    
4000c104:	02 80 00 13 	be  4000c150 <_Scheduler_CBS_Detach_thread+0x94>
4000c108:	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 )    
4000c10c:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000c110:	80 a0 80 19 	cmp  %g2, %i1                                  
4000c114:	12 80 00 0d 	bne  4000c148 <_Scheduler_CBS_Detach_thread+0x8c><== NEVER TAKEN
4000c118:	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;                                      
4000c11c:	c8 07 60 88 	ld  [ %i5 + 0x88 ], %g4                        
                                                                      
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
4000c120:	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;                
4000c124:	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;    
4000c128:	c4 07 60 a4 	ld  [ %i5 + 0xa4 ], %g2                        
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
4000c12c:	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;                                      
4000c130:	c0 21 20 18 	clr  [ %g4 + 0x18 ]                            
                                                                      
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;  
4000c134:	c6 27 60 78 	st  %g3, [ %i5 + 0x78 ]                        
  the_thread->budget_callout   = the_thread->Start.budget_callout;    
4000c138:	c4 27 60 7c 	st  %g2, [ %i5 + 0x7c ]                        
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;    
4000c13c:	c2 2f 60 70 	stb  %g1, [ %i5 + 0x70 ]                       
                                                                      
  return SCHEDULER_CBS_OK;                                            
4000c140:	81 c7 e0 08 	ret                                            
4000c144:	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;                     
4000c148:	81 c7 e0 08 	ret                                            
4000c14c:	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;                                            
}                                                                     
4000c150:	81 c7 e0 08 	ret                                            
4000c154:	91 e8 3f e7 	restore  %g0, -25, %o0                         
                                                                      

4000c330 <_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++ ) {
4000c330:	03 10 00 8b 	sethi  %hi(0x40022c00), %g1                    
4000c334:	c6 00 61 20 	ld  [ %g1 + 0x120 ], %g3	! 40022d20 <_Scheduler_CBS_Maximum_servers>
4000c338:	80 a0 e0 00 	cmp  %g3, 0                                    
4000c33c:	02 80 00 11 	be  4000c380 <_Scheduler_CBS_Get_server_id+0x50><== NEVER TAKEN
4000c340:	03 10 00 90 	sethi  %hi(0x40024000), %g1                    
4000c344:	c8 00 60 28 	ld  [ %g1 + 0x28 ], %g4	! 40024028 <_Scheduler_CBS_Server_list>
4000c348:	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 (                                    
4000c34c:	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] &&                             
4000c350:	c4 01 00 02 	ld  [ %g4 + %g2 ], %g2                         
4000c354:	80 a0 a0 00 	cmp  %g2, 0                                    
4000c358:	22 80 00 07 	be,a   4000c374 <_Scheduler_CBS_Get_server_id+0x44>
4000c35c:	82 00 60 01 	inc  %g1                                       
4000c360:	c4 00 80 00 	ld  [ %g2 ], %g2                               
4000c364:	80 a0 80 08 	cmp  %g2, %o0                                  
4000c368:	22 80 00 08 	be,a   4000c388 <_Scheduler_CBS_Get_server_id+0x58>
4000c36c:	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++ ) {              
4000c370:	82 00 60 01 	inc  %g1                                       
4000c374:	80 a0 40 03 	cmp  %g1, %g3                                  
4000c378:	12 bf ff f6 	bne  4000c350 <_Scheduler_CBS_Get_server_id+0x20>
4000c37c:	85 28 60 02 	sll  %g1, 2, %g2                               
      *server_id = i;                                                 
      return SCHEDULER_CBS_OK;                                        
    }                                                                 
  }                                                                   
  return SCHEDULER_CBS_ERROR_NOSERVER;                                
}                                                                     
4000c380:	81 c3 e0 08 	retl                                           
4000c384:	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;                                        
4000c388:	81 c3 e0 08 	retl                                           
4000c38c:	90 10 20 00 	clr  %o0                                       
                                                                      

4000c3fc <_Scheduler_CBS_Initialize>: } } int _Scheduler_CBS_Initialize(void) {
4000c3fc:	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*) );
4000c400:	3b 10 00 8b 	sethi  %hi(0x40022c00), %i5                    
4000c404:	d0 07 61 20 	ld  [ %i5 + 0x120 ], %o0	! 40022d20 <_Scheduler_CBS_Maximum_servers>
}                                                                     
                                                                      
int _Scheduler_CBS_Initialize(void)                                   
{                                                                     
  unsigned int i;                                                     
  _Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
4000c408:	40 00 07 09 	call  4000e02c <_Workspace_Allocate>           
4000c40c:	91 2a 20 02 	sll  %o0, 2, %o0                               
4000c410:	09 10 00 90 	sethi  %hi(0x40024000), %g4                    
      _Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
  if ( !_Scheduler_CBS_Server_list )                                  
4000c414:	80 a2 20 00 	cmp  %o0, 0                                    
4000c418:	02 80 00 10 	be  4000c458 <_Scheduler_CBS_Initialize+0x5c>  <== NEVER TAKEN
4000c41c:	d0 21 20 28 	st  %o0, [ %g4 + 0x28 ]                        
    return SCHEDULER_CBS_ERROR_NO_MEMORY;                             
  for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {                
4000c420:	c6 07 61 20 	ld  [ %i5 + 0x120 ], %g3                       
4000c424:	80 a0 e0 00 	cmp  %g3, 0                                    
4000c428:	12 80 00 05 	bne  4000c43c <_Scheduler_CBS_Initialize+0x40> <== ALWAYS TAKEN
4000c42c:	82 10 20 00 	clr  %g1                                       
    _Scheduler_CBS_Server_list[i] = NULL;                             
  }                                                                   
  return SCHEDULER_CBS_OK;                                            
4000c430:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000c434:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
4000c438:	d0 01 20 28 	ld  [ %g4 + 0x28 ], %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;                             
4000c43c:	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++) {                
4000c440:	82 00 60 01 	inc  %g1                                       
4000c444:	80 a0 40 03 	cmp  %g1, %g3                                  
4000c448:	12 bf ff fc 	bne  4000c438 <_Scheduler_CBS_Initialize+0x3c> 
4000c44c:	c0 22 00 02 	clr  [ %o0 + %g2 ]                             
    _Scheduler_CBS_Server_list[i] = NULL;                             
  }                                                                   
  return SCHEDULER_CBS_OK;                                            
4000c450:	81 c7 e0 08 	ret                                            
4000c454:	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;                             
4000c458:	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;                                            
}                                                                     
4000c45c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000c460:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000afec <_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;
4000afec:	c2 02 20 88 	ld  [ %o0 + 0x88 ], %g1                        
                                                                      
  if (deadline) {                                                     
4000aff0:	80 a2 60 00 	cmp  %o1, 0                                    
4000aff4:	02 80 00 11 	be  4000b038 <_Scheduler_CBS_Release_job+0x4c> 
4000aff8:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
    /* Initializing or shifting deadline. */                          
    if (serv_info)                                                    
4000affc:	80 a0 60 00 	cmp  %g1, 0                                    
4000b000:	02 80 00 13 	be  4000b04c <_Scheduler_CBS_Release_job+0x60> 
4000b004:	07 10 00 87 	sethi  %hi(0x40021c00), %g3                    
      new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
4000b008:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000b00c:	d2 00 e3 f8 	ld  [ %g3 + 0x3f8 ], %o1                       
4000b010:	92 02 40 02 	add  %o1, %g2, %o1                             
4000b014:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
4000b018:	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;       
4000b01c:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
4000b020:	c2 22 20 74 	st  %g1, [ %o0 + 0x74 ]                        
                                                                      
  the_thread->real_priority = new_priority;                           
4000b024:	d2 22 20 18 	st  %o1, [ %o0 + 0x18 ]                        
  _Thread_Change_priority(the_thread, new_priority, true);            
4000b028:	94 10 20 01 	mov  1, %o2                                    
4000b02c:	82 13 c0 00 	mov  %o7, %g1                                  
4000b030:	40 00 01 3a 	call  4000b518 <_Thread_Change_priority>       
4000b034:	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)                                                      
4000b038:	80 a0 60 00 	cmp  %g1, 0                                    
4000b03c:	12 bf ff f8 	bne  4000b01c <_Scheduler_CBS_Release_job+0x30><== ALWAYS TAKEN
4000b040:	d2 02 20 ac 	ld  [ %o0 + 0xac ], %o1                        
    the_thread->cpu_time_budget = serv_info->parameters.budget;       
                                                                      
  the_thread->real_priority = new_priority;                           
4000b044:	10 bf ff f9 	b  4000b028 <_Scheduler_CBS_Release_job+0x3c>  <== NOT EXECUTED
4000b048:	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)          
4000b04c:	03 10 00 87 	sethi  %hi(0x40021c00), %g1                    
4000b050:	c2 00 63 f8 	ld  [ %g1 + 0x3f8 ], %g1	! 40021ff8 <_Watchdog_Ticks_since_boot>
4000b054:	92 02 40 01 	add  %o1, %g1, %o1                             
4000b058:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
4000b05c:	10 bf ff f2 	b  4000b024 <_Scheduler_CBS_Release_job+0x38>  
4000b060:	92 2a 40 01 	andn  %o1, %g1, %o1                            
                                                                      

4000b064 <_Scheduler_CBS_Unblock>: #include <rtems/score/schedulercbs.h> void _Scheduler_CBS_Unblock( Thread_Control *the_thread ) {
4000b064:	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);                                 
4000b068:	40 00 00 50 	call  4000b1a8 <_Scheduler_EDF_Enqueue>        
4000b06c:	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;        
4000b070:	c2 06 20 88 	ld  [ %i0 + 0x88 ], %g1                        
4000b074:	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) {                                                    
4000b078:	80 a7 60 00 	cmp  %i5, 0                                    
4000b07c:	02 80 00 19 	be  4000b0e0 <_Scheduler_CBS_Unblock+0x7c>     
4000b080:	03 10 00 87 	sethi  %hi(0x40021c00), %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 ) {              
4000b084:	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 -                  
4000b088:	d0 00 63 f8 	ld  [ %g1 + 0x3f8 ], %o0                       
4000b08c:	f8 06 20 18 	ld  [ %i0 + 0x18 ], %i4                        
                           _Watchdog_Ticks_since_boot;                
                                                                      
    if ( deadline*budget_left > budget*deadline_left ) {              
4000b090:	40 00 40 c1 	call  4001b394 <.umul>                         
4000b094:	90 27 00 08 	sub  %i4, %o0, %o0                             
4000b098:	d2 06 20 74 	ld  [ %i0 + 0x74 ], %o1                        
4000b09c:	b6 10 00 08 	mov  %o0, %i3                                  
4000b0a0:	40 00 40 bd 	call  4001b394 <.umul>                         
4000b0a4:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
4000b0a8:	80 a6 c0 08 	cmp  %i3, %o0                                  
4000b0ac:	24 80 00 0e 	ble,a   4000b0e4 <_Scheduler_CBS_Unblock+0x80> 
4000b0b0:	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;              
4000b0b4:	d2 06 20 ac 	ld  [ %i0 + 0xac ], %o1                        
      if ( the_thread->real_priority != new_priority )                
4000b0b8:	80 a7 00 09 	cmp  %i4, %o1                                  
4000b0bc:	32 80 00 02 	bne,a   4000b0c4 <_Scheduler_CBS_Unblock+0x60> 
4000b0c0:	d2 26 20 18 	st  %o1, [ %i0 + 0x18 ]                        
        the_thread->real_priority = new_priority;                     
      if ( the_thread->current_priority != new_priority )             
4000b0c4:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
4000b0c8:	80 a2 00 09 	cmp  %o0, %o1                                  
4000b0cc:	02 80 00 07 	be  4000b0e8 <_Scheduler_CBS_Unblock+0x84>     
4000b0d0:	3b 10 00 89 	sethi  %hi(0x40022400), %i5                    
        _Thread_Change_priority(the_thread, new_priority, true);      
4000b0d4:	90 10 00 18 	mov  %i0, %o0                                  
4000b0d8:	40 00 01 10 	call  4000b518 <_Thread_Change_priority>       
4000b0dc:	94 10 20 01 	mov  1, %o2                                    
4000b0e0:	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,
4000b0e4:	3b 10 00 89 	sethi  %hi(0x40022400), %i5                    
4000b0e8:	ba 17 60 20 	or  %i5, 0x20, %i5	! 40022420 <_Per_CPU_Information>
4000b0ec:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4000b0f0:	d2 00 60 14 	ld  [ %g1 + 0x14 ], %o1                        
4000b0f4:	03 10 00 84 	sethi  %hi(0x40021000), %g1                    
4000b0f8:	c2 00 61 74 	ld  [ %g1 + 0x174 ], %g1	! 40021174 <_Scheduler+0x30>
4000b0fc:	9f c0 40 00 	call  %g1                                      
4000b100:	01 00 00 00 	nop                                            
4000b104:	80 a2 20 00 	cmp  %o0, 0                                    
4000b108:	04 80 00 0a 	ble  4000b130 <_Scheduler_CBS_Unblock+0xcc>    
4000b10c:	01 00 00 00 	nop                                            
       _Thread_Heir->current_priority)) {                             
    _Thread_Heir = the_thread;                                        
    if ( _Thread_Executing->is_preemptible ||                         
4000b110:	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;                                        
4000b114:	f0 27 60 14 	st  %i0, [ %i5 + 0x14 ]                        
    if ( _Thread_Executing->is_preemptible ||                         
4000b118:	c2 08 60 70 	ldub  [ %g1 + 0x70 ], %g1                      
4000b11c:	80 a0 60 00 	cmp  %g1, 0                                    
4000b120:	22 80 00 06 	be,a   4000b138 <_Scheduler_CBS_Unblock+0xd4>  
4000b124:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
4000b128:	82 10 20 01 	mov  1, %g1                                    
4000b12c:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        
4000b130:	81 c7 e0 08 	ret                                            
4000b134:	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 ||                         
4000b138:	80 a0 60 00 	cmp  %g1, 0                                    
4000b13c:	12 bf ff fd 	bne  4000b130 <_Scheduler_CBS_Unblock+0xcc>    <== ALWAYS TAKEN
4000b140:	82 10 20 01 	mov  1, %g1                                    
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
4000b144:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        <== NOT EXECUTED
4000b148:	30 bf ff fa 	b,a   4000b130 <_Scheduler_CBS_Unblock+0xcc>   <== NOT EXECUTED
                                                                      

4000afbc <_Scheduler_EDF_Allocate>: #include <rtems/score/wkspace.h> void *_Scheduler_EDF_Allocate( Thread_Control *the_thread ) {
4000afbc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *sched;                                                        
  Scheduler_EDF_Per_thread *schinfo;                                  
                                                                      
  sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );    
4000afc0:	40 00 06 e8 	call  4000cb60 <_Workspace_Allocate>           
4000afc4:	90 10 20 18 	mov  0x18, %o0                                 
                                                                      
  if ( sched ) {                                                      
4000afc8:	80 a2 20 00 	cmp  %o0, 0                                    
4000afcc:	02 80 00 05 	be  4000afe0 <_Scheduler_EDF_Allocate+0x24>    <== NEVER TAKEN
4000afd0:	82 10 20 02 	mov  2, %g1                                    
    the_thread->scheduler_info = sched;                               
4000afd4:	d0 26 20 88 	st  %o0, [ %i0 + 0x88 ]                        
    schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
    schinfo->thread = the_thread;                                     
4000afd8:	f0 22 00 00 	st  %i0, [ %o0 ]                               
    schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;  
4000afdc:	c2 22 20 14 	st  %g1, [ %o0 + 0x14 ]                        
  }                                                                   
                                                                      
  return sched;                                                       
}                                                                     
4000afe0:	81 c7 e0 08 	ret                                            
4000afe4:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

4000b1a0 <_Scheduler_EDF_Unblock>: #include <rtems/score/scheduleredf.h> void _Scheduler_EDF_Unblock( Thread_Control *the_thread ) {
4000b1a0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  _Scheduler_EDF_Enqueue(the_thread);                                 
4000b1a4:	7f ff ff a8 	call  4000b044 <_Scheduler_EDF_Enqueue>        
4000b1a8:	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(                             
4000b1ac:	3b 10 00 88 	sethi  %hi(0x40022000), %i5                    
4000b1b0:	ba 17 63 80 	or  %i5, 0x380, %i5	! 40022380 <_Per_CPU_Information>
4000b1b4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4000b1b8:	d0 00 60 14 	ld  [ %g1 + 0x14 ], %o0                        
4000b1bc:	03 10 00 84 	sethi  %hi(0x40021000), %g1                    
4000b1c0:	c2 00 60 d4 	ld  [ %g1 + 0xd4 ], %g1	! 400210d4 <_Scheduler+0x30>
4000b1c4:	9f c0 40 00 	call  %g1                                      
4000b1c8:	d2 06 20 14 	ld  [ %i0 + 0x14 ], %o1                        
4000b1cc:	80 a2 20 00 	cmp  %o0, 0                                    
4000b1d0:	26 80 00 04 	bl,a   4000b1e0 <_Scheduler_EDF_Unblock+0x40>  
4000b1d4:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000b1d8:	81 c7 e0 08 	ret                                            
4000b1dc:	81 e8 00 00 	restore                                        
         _Thread_Heir->current_priority,                              
         the_thread->current_priority )) {                            
    _Thread_Heir = the_thread;                                        
4000b1e0:	f0 27 60 14 	st  %i0, [ %i5 + 0x14 ]                        
    if ( _Thread_Executing->is_preemptible ||                         
4000b1e4:	c2 08 60 70 	ldub  [ %g1 + 0x70 ], %g1                      
4000b1e8:	80 a0 60 00 	cmp  %g1, 0                                    
4000b1ec:	22 80 00 06 	be,a   4000b204 <_Scheduler_EDF_Unblock+0x64>  
4000b1f0:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
4000b1f4:	82 10 20 01 	mov  1, %g1                                    
4000b1f8:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        
4000b1fc:	81 c7 e0 08 	ret                                            
4000b200:	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 ||                         
4000b204:	80 a0 60 00 	cmp  %g1, 0                                    
4000b208:	12 bf ff f4 	bne  4000b1d8 <_Scheduler_EDF_Unblock+0x38>    <== ALWAYS TAKEN
4000b20c:	82 10 20 01 	mov  1, %g1                                    
         the_thread->current_priority == 0 )                          
      _Thread_Dispatch_necessary = true;                              
4000b210:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        <== NOT EXECUTED
4000b214:	30 bf ff fa 	b,a   4000b1fc <_Scheduler_EDF_Unblock+0x5c>   <== NOT EXECUTED
                                                                      

4000a910 <_Scheduler_priority_Tick>: #include <rtems/system.h> #include <rtems/score/schedulerpriority.h> void _Scheduler_priority_Tick( void ) {
4000a910:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control *executing;                                          
                                                                      
  executing = _Thread_Executing;                                      
4000a914:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
4000a918:	d0 00 63 d0 	ld  [ %g1 + 0x3d0 ], %o0	! 400207d0 <_Per_CPU_Information+0x10>
  /*                                                                  
   *  If the thread is not preemptible or is not ready, then          
   *  just return.                                                    
   */                                                                 
                                                                      
  if ( !executing->is_preemptible )                                   
4000a91c:	c2 0a 20 70 	ldub  [ %o0 + 0x70 ], %g1                      
4000a920:	80 a0 60 00 	cmp  %g1, 0                                    
4000a924:	02 80 00 26 	be  4000a9bc <_Scheduler_priority_Tick+0xac>   
4000a928:	01 00 00 00 	nop                                            
    return;                                                           
                                                                      
  if ( !_States_Is_ready( executing->current_state ) )                
4000a92c:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
4000a930:	80 a0 60 00 	cmp  %g1, 0                                    
4000a934:	12 80 00 22 	bne  4000a9bc <_Scheduler_priority_Tick+0xac>  
4000a938:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  The cpu budget algorithm determines what happens next.          
   */                                                                 
                                                                      
  switch ( executing->budget_algorithm ) {                            
4000a93c:	c2 02 20 78 	ld  [ %o0 + 0x78 ], %g1                        
4000a940:	80 a0 60 01 	cmp  %g1, 1                                    
4000a944:	0a 80 00 07 	bcs  4000a960 <_Scheduler_priority_Tick+0x50>  
4000a948:	80 a0 60 02 	cmp  %g1, 2                                    
4000a94c:	28 80 00 10 	bleu,a   4000a98c <_Scheduler_priority_Tick+0x7c>
4000a950:	c2 02 20 74 	ld  [ %o0 + 0x74 ], %g1                        
4000a954:	80 a0 60 03 	cmp  %g1, 3                                    
4000a958:	22 80 00 04 	be,a   4000a968 <_Scheduler_priority_Tick+0x58><== ALWAYS TAKEN
4000a95c:	c2 02 20 74 	ld  [ %o0 + 0x74 ], %g1                        
4000a960:	81 c7 e0 08 	ret                                            
4000a964:	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 )                             
4000a968:	82 00 7f ff 	add  %g1, -1, %g1                              
4000a96c:	80 a0 60 00 	cmp  %g1, 0                                    
4000a970:	12 bf ff fc 	bne  4000a960 <_Scheduler_priority_Tick+0x50>  
4000a974:	c2 22 20 74 	st  %g1, [ %o0 + 0x74 ]                        
	  (*executing->budget_callout)( executing );                         
4000a978:	c2 02 20 7c 	ld  [ %o0 + 0x7c ], %g1                        
4000a97c:	9f c0 40 00 	call  %g1                                      
4000a980:	01 00 00 00 	nop                                            
4000a984:	81 c7 e0 08 	ret                                            
4000a988:	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 ) {               
4000a98c:	82 00 7f ff 	add  %g1, -1, %g1                              
4000a990:	80 a0 60 00 	cmp  %g1, 0                                    
4000a994:	14 bf ff f3 	bg  4000a960 <_Scheduler_priority_Tick+0x50>   
4000a998:	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();                                      
4000a99c:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
4000a9a0:	c2 00 61 70 	ld  [ %g1 + 0x170 ], %g1	! 4001f570 <_Scheduler+0xc>
4000a9a4:	9f c0 40 00 	call  %g1                                      
4000a9a8:	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;     
4000a9ac:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000a9b0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
4000a9b4:	c2 00 62 10 	ld  [ %g1 + 0x210 ], %g1                       
4000a9b8:	c2 22 20 74 	st  %g1, [ %o0 + 0x74 ]                        
4000a9bc:	81 c7 e0 08 	ret                                            
4000a9c0:	81 e8 00 00 	restore                                        
                                                                      

4000b1b8 <_Scheduler_simple_Ready_queue_enqueue_first>: { Chain_Control *ready; Chain_Node *the_node; Thread_Control *current; ready = (Chain_Control *)_Scheduler.information;
4000b1b8:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000b1bc:	c2 00 61 64 	ld  [ %g1 + 0x164 ], %g1	! 40020564 <_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 ) {
4000b1c0:	c6 02 20 14 	ld  [ %o0 + 0x14 ], %g3                        
4000b1c4:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000b1c8:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
4000b1cc:	80 a0 80 03 	cmp  %g2, %g3                                  
4000b1d0:	3a 80 00 08 	bcc,a   4000b1f0 <_Scheduler_simple_Ready_queue_enqueue_first+0x38>
4000b1d4:	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 ) {
4000b1d8:	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 ) {
4000b1dc:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
4000b1e0:	80 a0 80 03 	cmp  %g2, %g3                                  
4000b1e4:	2a bf ff fe 	bcs,a   4000b1dc <_Scheduler_simple_Ready_queue_enqueue_first+0x24><== NEVER TAKEN
4000b1e8:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
      current = (Thread_Control *)current->Object.Node.previous;      
4000b1ec:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000b1f0:	c4 00 40 00 	ld  [ %g1 ], %g2                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000b1f4:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000b1f8:	d0 20 40 00 	st  %o0, [ %g1 ]                               
  the_node->next        = before_node;                                
4000b1fc:	c4 22 00 00 	st  %g2, [ %o0 ]                               
  before_node->previous = the_node;                                   
4000b200:	81 c3 e0 08 	retl                                           
4000b204:	d0 20 a0 04 	st  %o0, [ %g2 + 4 ]                           
                                                                      

40009234 <_TOD_Validate>: }; bool _TOD_Validate( const rtems_time_of_day *the_tod ) {
40009234:	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();                 
40009238:	03 10 00 7e 	sethi  %hi(0x4001f800), %g1                    
)                                                                     
{                                                                     
  uint32_t   days_in_month;                                           
  uint32_t   ticks_per_second;                                        
                                                                      
  ticks_per_second = TOD_MICROSECONDS_PER_SECOND /                    
4000923c:	d2 00 60 7c 	ld  [ %g1 + 0x7c ], %o1	! 4001f87c <Configuration+0xc>
40009240:	11 00 03 d0 	sethi  %hi(0xf4000), %o0                       
40009244:	40 00 4a 77 	call  4001bc20 <.udiv>                         
40009248:	90 12 22 40 	or  %o0, 0x240, %o0	! f4240 <PROM_START+0xf4240>
	    rtems_configuration_get_microseconds_per_tick();                 
  if ((!the_tod)                                  ||                  
4000924c:	80 a6 20 00 	cmp  %i0, 0                                    
40009250:	02 80 00 2c 	be  40009300 <_TOD_Validate+0xcc>              <== NEVER TAKEN
40009254:	82 10 20 00 	clr  %g1                                       
40009258:	c4 06 20 18 	ld  [ %i0 + 0x18 ], %g2                        
4000925c:	80 a2 00 02 	cmp  %o0, %g2                                  
40009260:	28 80 00 26 	bleu,a   400092f8 <_TOD_Validate+0xc4>         
40009264:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->ticks  >= ticks_per_second)       ||                  
40009268:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
4000926c:	80 a0 a0 3b 	cmp  %g2, 0x3b                                 
40009270:	38 80 00 22 	bgu,a   400092f8 <_TOD_Validate+0xc4>          
40009274:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->second >= TOD_SECONDS_PER_MINUTE) ||                  
40009278:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4000927c:	80 a0 a0 3b 	cmp  %g2, 0x3b                                 
40009280:	38 80 00 1e 	bgu,a   400092f8 <_TOD_Validate+0xc4>          
40009284:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->minute >= TOD_MINUTES_PER_HOUR)   ||                  
40009288:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2                         
4000928c:	80 a0 a0 17 	cmp  %g2, 0x17                                 
40009290:	38 80 00 1a 	bgu,a   400092f8 <_TOD_Validate+0xc4>          
40009294:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->hour   >= TOD_HOURS_PER_DAY)      ||                  
      (the_tod->month  == 0)                      ||                  
40009298:	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)      ||                  
4000929c:	80 a0 a0 00 	cmp  %g2, 0                                    
400092a0:	02 80 00 15 	be  400092f4 <_TOD_Validate+0xc0>              <== NEVER TAKEN
400092a4:	80 a0 a0 0c 	cmp  %g2, 0xc                                  
      (the_tod->month  == 0)                      ||                  
400092a8:	38 80 00 14 	bgu,a   400092f8 <_TOD_Validate+0xc4>          
400092ac:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->month  >  TOD_MONTHS_PER_YEAR)    ||                  
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
400092b0:	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)    ||                  
400092b4:	80 a0 e7 c3 	cmp  %g3, 0x7c3                                
400092b8:	28 80 00 10 	bleu,a   400092f8 <_TOD_Validate+0xc4>         
400092bc:	b0 08 60 01 	and  %g1, 1, %i0                               
      (the_tod->year   <  TOD_BASE_YEAR)          ||                  
      (the_tod->day    == 0) )                                        
400092c0:	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)          ||                  
400092c4:	80 a1 20 00 	cmp  %g4, 0                                    
400092c8:	02 80 00 0b 	be  400092f4 <_TOD_Validate+0xc0>              <== NEVER TAKEN
400092cc:	80 88 e0 03 	btst  3, %g3                                   
      (the_tod->day    == 0) )                                        
     return false;                                                    
                                                                      
  if ( (the_tod->year % 4) == 0 )                                     
400092d0:	32 80 00 0f 	bne,a   4000930c <_TOD_Validate+0xd8>          
400092d4:	85 28 a0 02 	sll  %g2, 2, %g2                               
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];       
400092d8:	82 00 a0 0d 	add  %g2, 0xd, %g1                             
400092dc:	05 10 00 82 	sethi  %hi(0x40020800), %g2                    
400092e0:	83 28 60 02 	sll  %g1, 2, %g1                               
400092e4:	84 10 a1 68 	or  %g2, 0x168, %g2                            
400092e8:	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 )                                 
400092ec:	80 a0 40 04 	cmp  %g1, %g4                                  
400092f0:	82 60 3f ff 	subx  %g0, -1, %g1                             
    return false;                                                     
                                                                      
  return true;                                                        
}                                                                     
400092f4:	b0 08 60 01 	and  %g1, 1, %i0                               
400092f8:	81 c7 e0 08 	ret                                            
400092fc:	81 e8 00 00 	restore                                        
40009300:	b0 08 60 01 	and  %g1, 1, %i0                               <== NOT EXECUTED
40009304:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40009308:	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 ];       
4000930c:	03 10 00 82 	sethi  %hi(0x40020800), %g1                    
40009310:	82 10 61 68 	or  %g1, 0x168, %g1	! 40020968 <_TOD_Days_per_month>
40009314:	c2 00 40 02 	ld  [ %g1 + %g2 ], %g1                         
                                                                      
  if ( the_tod->day > days_in_month )                                 
40009318:	80 a0 40 04 	cmp  %g1, %g4                                  
4000931c:	10 bf ff f6 	b  400092f4 <_TOD_Validate+0xc0>               
40009320:	82 60 3f ff 	subx  %g0, -1, %g1                             
                                                                      

4000abe0 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) {
4000abe0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  States_Control state, original_state;                               
                                                                      
  /*                                                                  
   * Save original state                                              
   */                                                                 
  original_state = the_thread->current_state;                         
4000abe4:	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 );                                
4000abe8:	40 00 03 9a 	call  4000ba50 <_Thread_Set_transient>         
4000abec:	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 )                  
4000abf0:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4000abf4:	80 a0 40 19 	cmp  %g1, %i1                                  
4000abf8:	02 80 00 05 	be  4000ac0c <_Thread_Change_priority+0x2c>    
4000abfc:	ba 10 00 18 	mov  %i0, %i5                                  
    _Thread_Set_priority( the_thread, new_priority );                 
4000ac00:	90 10 00 18 	mov  %i0, %o0                                  
4000ac04:	40 00 03 79 	call  4000b9e8 <_Thread_Set_priority>          
4000ac08:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  _ISR_Disable( level );                                              
4000ac0c:	7f ff de 31 	call  400024d0 <sparc_disable_interrupts>      
4000ac10:	01 00 00 00 	nop                                            
4000ac14:	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;                                  
4000ac18:	f8 07 60 10 	ld  [ %i5 + 0x10 ], %i4                        
  if ( state != STATES_TRANSIENT ) {                                  
4000ac1c:	80 a7 20 04 	cmp  %i4, 4                                    
4000ac20:	02 80 00 18 	be  4000ac80 <_Thread_Change_priority+0xa0>    
4000ac24:	80 8e e0 04 	btst  4, %i3                                   
    /* Only clear the transient state if it wasn't set already */     
    if ( ! _States_Is_transient( original_state ) )                   
4000ac28:	02 80 00 0b 	be  4000ac54 <_Thread_Change_priority+0x74>    <== ALWAYS TAKEN
4000ac2c:	82 0f 3f fb 	and  %i4, -5, %g1                              
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
    _ISR_Enable( level );                                             
4000ac30:	7f ff de 2c 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
4000ac34:	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);              
4000ac38:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       <== NOT EXECUTED
4000ac3c:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0><== NOT EXECUTED
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
4000ac40:	80 8f 00 01 	btst  %i4, %g1                                 <== NOT EXECUTED
4000ac44:	32 80 00 0d 	bne,a   4000ac78 <_Thread_Change_priority+0x98><== NOT EXECUTED
4000ac48:	f0 07 60 44 	ld  [ %i5 + 0x44 ], %i0                        <== NOT EXECUTED
4000ac4c:	81 c7 e0 08 	ret                                            
4000ac50:	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 );
4000ac54:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
    _ISR_Enable( level );                                             
4000ac58:	7f ff de 22 	call  400024e0 <sparc_enable_interrupts>       
4000ac5c:	90 10 00 19 	mov  %i1, %o0                                  
4000ac60:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
4000ac64:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
    if ( _States_Is_waiting_on_thread_queue( state ) ) {              
4000ac68:	80 8f 00 01 	btst  %i4, %g1                                 
4000ac6c:	02 bf ff f8 	be  4000ac4c <_Thread_Change_priority+0x6c>    
4000ac70:	01 00 00 00 	nop                                            
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );    
4000ac74:	f0 07 60 44 	ld  [ %i5 + 0x44 ], %i0                        
4000ac78:	40 00 03 2c 	call  4000b928 <_Thread_queue_Requeue>         
4000ac7c:	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 ) ) {                   
4000ac80:	22 80 00 19 	be,a   4000ace4 <_Thread_Change_priority+0x104><== ALWAYS TAKEN
4000ac84:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
4000ac88:	39 10 00 7d 	sethi  %hi(0x4001f400), %i4                    <== NOT EXECUTED
4000ac8c:	b8 17 21 64 	or  %i4, 0x164, %i4	! 4001f564 <_Scheduler>    <== NOT EXECUTED
      _Scheduler_Enqueue_first( the_thread );                         
    else                                                              
      _Scheduler_Enqueue( the_thread );                               
  }                                                                   
                                                                      
  _ISR_Flash( level );                                                
4000ac90:	7f ff de 14 	call  400024e0 <sparc_enable_interrupts>       
4000ac94:	90 10 00 19 	mov  %i1, %o0                                  
4000ac98:	7f ff de 0e 	call  400024d0 <sparc_disable_interrupts>      
4000ac9c:	01 00 00 00 	nop                                            
4000aca0:	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();                                   
4000aca4:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
4000aca8:	9f c0 40 00 	call  %g1                                      
4000acac:	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 );                       
4000acb0:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
4000acb4:	82 10 63 c0 	or  %g1, 0x3c0, %g1	! 400207c0 <_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() &&                       
4000acb8:	c4 18 60 10 	ldd  [ %g1 + 0x10 ], %g2                       
4000acbc:	80 a0 80 03 	cmp  %g2, %g3                                  
4000acc0:	02 80 00 07 	be  4000acdc <_Thread_Change_priority+0xfc>    
4000acc4:	01 00 00 00 	nop                                            
4000acc8:	c4 08 a0 70 	ldub  [ %g2 + 0x70 ], %g2                      
4000accc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000acd0:	02 80 00 03 	be  4000acdc <_Thread_Change_priority+0xfc>    
4000acd4:	84 10 20 01 	mov  1, %g2                                    
       _Thread_Executing->is_preemptible )                            
    _Thread_Dispatch_necessary = true;                                
4000acd8:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]                        
  _ISR_Enable( level );                                               
4000acdc:	7f ff de 01 	call  400024e0 <sparc_enable_interrupts>       
4000ace0:	81 e8 00 00 	restore                                        
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(                   
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue_first( the_thread );                  
4000ace4:	39 10 00 7d 	sethi  %hi(0x4001f400), %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 )                                                 
4000ace8:	80 a6 a0 00 	cmp  %i2, 0                                    
4000acec:	02 80 00 06 	be  4000ad04 <_Thread_Change_priority+0x124>   
4000acf0:	b8 17 21 64 	or  %i4, 0x164, %i4                            
4000acf4:	c2 07 20 28 	ld  [ %i4 + 0x28 ], %g1                        
4000acf8:	9f c0 40 00 	call  %g1                                      
4000acfc:	90 10 00 1d 	mov  %i5, %o0                                  
4000ad00:	30 bf ff e4 	b,a   4000ac90 <_Thread_Change_priority+0xb0>  
 */                                                                   
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(                         
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  _Scheduler.Operations.enqueue( the_thread );                        
4000ad04:	c2 07 20 24 	ld  [ %i4 + 0x24 ], %g1                        
4000ad08:	9f c0 40 00 	call  %g1                                      
4000ad0c:	90 10 00 1d 	mov  %i5, %o0                                  
4000ad10:	30 bf ff e0 	b,a   4000ac90 <_Thread_Change_priority+0xb0>  
                                                                      

4000af00 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) {
4000af00:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control    *the_thread;                                      
  Objects_Locations  location;                                        
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000af04:	90 10 00 18 	mov  %i0, %o0                                  
4000af08:	40 00 00 7c 	call  4000b0f8 <_Thread_Get>                   
4000af0c:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000af10:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000af14:	80 a0 60 00 	cmp  %g1, 0                                    
4000af18:	12 80 00 08 	bne  4000af38 <_Thread_Delay_ended+0x38>       <== NEVER TAKEN
4000af1c:	13 04 00 00 	sethi  %hi(0x10000000), %o1                    
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_Clear_state(                                            
4000af20:	7f ff ff 7d 	call  4000ad14 <_Thread_Clear_state>           
4000af24:	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;                  
4000af28:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000af2c:	c4 00 62 b0 	ld  [ %g1 + 0x2b0 ], %g2	! 400202b0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
4000af30:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
4000af34:	c4 20 62 b0 	st  %g2, [ %g1 + 0x2b0 ]                       
4000af38:	81 c7 e0 08 	ret                                            
4000af3c:	81 e8 00 00 	restore                                        
                                                                      

4000af40 <_Thread_Dispatch>: #if defined(RTEMS_SMP) #include <rtems/score/smp.h> #endif void _Thread_Dispatch( void ) {
4000af40:	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;                                    
4000af44:	31 10 00 81 	sethi  %hi(0x40020400), %i0                    
4000af48:	b0 16 23 c0 	or  %i0, 0x3c0, %i0	! 400207c0 <_Per_CPU_Information>
  _ISR_Disable( level );                                              
4000af4c:	7f ff dd 61 	call  400024d0 <sparc_disable_interrupts>      
4000af50:	f6 06 20 10 	ld  [ %i0 + 0x10 ], %i3                        
  while ( _Thread_Dispatch_necessary == true ) {                      
4000af54:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
4000af58:	80 a0 60 00 	cmp  %g1, 0                                    
4000af5c:	02 80 00 46 	be  4000b074 <_Thread_Dispatch+0x134>          
4000af60:	21 10 00 80 	sethi  %hi(0x40020000), %l0                    
    heir = _Thread_Heir;                                              
4000af64:	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;                           
4000af68:	82 10 20 01 	mov  1, %g1                                    
4000af6c:	c2 24 22 b0 	st  %g1, [ %l0 + 0x2b0 ]                       
    #ifndef RTEMS_SMP                                                 
      _Thread_Dispatch_set_disable_level( 1 );                        
    #endif                                                            
    _Thread_Dispatch_necessary = false;                               
4000af70:	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 )                                          
4000af74:	80 a6 c0 1a 	cmp  %i3, %i2                                  
4000af78:	02 80 00 3f 	be  4000b074 <_Thread_Dispatch+0x134>          
4000af7c:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        
4000af80:	23 10 00 7d 	sethi  %hi(0x4001f400), %l1                    
4000af84:	27 10 00 80 	sethi  %hi(0x40020000), %l3                    
4000af88:	a2 14 62 90 	or  %l1, 0x290, %l1                            
 */                                                                   
static inline void _TOD_Get_uptime(                                   
  Timestamp_Control *time                                             
)                                                                     
{                                                                     
  _TOD_Get_with_nanoseconds( time, &_TOD.uptime );                    
4000af8c:	25 10 00 80 	sethi  %hi(0x40020000), %l2                    
4000af90:	a6 14 e3 1c 	or  %l3, 0x31c, %l3                            
4000af94:	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;            
4000af98:	2b 10 00 80 	sethi  %hi(0x40020000), %l5                    
4000af9c:	a4 14 a2 00 	or  %l2, 0x200, %l2                            
4000afa0:	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 )
4000afa4:	c2 06 a0 78 	ld  [ %i2 + 0x78 ], %g1                        
4000afa8:	80 a0 60 01 	cmp  %g1, 1                                    
4000afac:	02 80 00 45 	be  4000b0c0 <_Thread_Dispatch+0x180>          
4000afb0:	c2 05 62 10 	ld  [ %l5 + 0x210 ], %g1                       
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;            
                                                                      
    _ISR_Enable( level );                                             
4000afb4:	7f ff dd 4b 	call  400024e0 <sparc_enable_interrupts>       
4000afb8:	01 00 00 00 	nop                                            
4000afbc:	90 07 bf f8 	add  %fp, -8, %o0                              
4000afc0:	7f ff f9 8b 	call  400095ec <_TOD_Get_with_nanoseconds>     
4000afc4:	92 10 00 12 	mov  %l2, %o1                                  
4000afc8:	c4 1e e0 80 	ldd  [ %i3 + 0x80 ], %g2                       
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
4000afcc:	f8 1e 20 20 	ldd  [ %i0 + 0x20 ], %i4                       
                                                                      
    #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                        
      {                                                               
        Timestamp_Control uptime, ran;                                
        _TOD_Get_uptime( &uptime );                                   
        _Timestamp_Subtract(                                          
4000afd0:	d8 1f bf f8 	ldd  [ %fp + -8 ], %o4                         
    #endif                                                            
                                                                      
    /*                                                                
     * Switch libc's task specific data.                              
     */                                                               
    if ( _Thread_libc_reent ) {                                       
4000afd4:	c2 04 c0 00 	ld  [ %l3 ], %g1                               
4000afd8:	ba a3 40 1d 	subcc  %o5, %i5, %i5                           
4000afdc:	b8 63 00 1c 	subx  %o4, %i4, %i4                            
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
4000afe0:	96 80 c0 1d 	addcc  %g3, %i5, %o3                           
4000afe4:	94 40 80 1c 	addx  %g2, %i4, %o2                            
4000afe8:	d4 3e e0 80 	std  %o2, [ %i3 + 0x80 ]                       
4000afec:	80 a0 60 00 	cmp  %g1, 0                                    
4000aff0:	02 80 00 06 	be  4000b008 <_Thread_Dispatch+0xc8>           <== NEVER TAKEN
4000aff4:	d8 3e 20 20 	std  %o4, [ %i0 + 0x20 ]                       
      executing->libc_reent = *_Thread_libc_reent;                    
4000aff8:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000affc:	c4 26 e1 48 	st  %g2, [ %i3 + 0x148 ]                       
      *_Thread_libc_reent = heir->libc_reent;                         
4000b000:	c4 06 a1 48 	ld  [ %i2 + 0x148 ], %g2                       
4000b004:	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;                    
4000b008:	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 ) {                                            
4000b00c:	80 a7 40 19 	cmp  %i5, %i1                                  
4000b010:	02 80 00 0b 	be  4000b03c <_Thread_Dispatch+0xfc>           <== NEVER TAKEN
4000b014:	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 );                   
4000b018:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000b01c:	90 10 00 1b 	mov  %i3, %o0                                  
4000b020:	9f c0 40 00 	call  %g1                                      
4000b024:	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;                                              
4000b028:	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 ) {                                            
4000b02c:	80 a7 40 19 	cmp  %i5, %i1                                  
4000b030:	32 bf ff fb 	bne,a   4000b01c <_Thread_Dispatch+0xdc>       
4000b034:	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 );       
4000b038:	90 06 e0 c0 	add  %i3, 0xc0, %o0                            
4000b03c:	40 00 04 91 	call  4000c280 <_CPU_Context_switch>           
4000b040:	92 06 a0 c0 	add  %i2, 0xc0, %o1                            
#endif                                                                
#endif                                                                
                                                                      
    executing = _Thread_Executing;                                    
                                                                      
    _ISR_Disable( level );                                            
4000b044:	7f ff dd 23 	call  400024d0 <sparc_disable_interrupts>      
4000b048:	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 ) {                      
4000b04c:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
4000b050:	80 a0 60 00 	cmp  %g1, 0                                    
4000b054:	02 80 00 08 	be  4000b074 <_Thread_Dispatch+0x134>          
4000b058:	01 00 00 00 	nop                                            
    heir = _Thread_Heir;                                              
4000b05c:	f4 06 20 14 	ld  [ %i0 + 0x14 ], %i2                        
4000b060:	e8 24 22 b0 	st  %l4, [ %l0 + 0x2b0 ]                       
    #ifndef RTEMS_SMP                                                 
      _Thread_Dispatch_set_disable_level( 1 );                        
    #endif                                                            
    _Thread_Dispatch_necessary = false;                               
4000b064:	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 )                                          
4000b068:	80 a6 80 1b 	cmp  %i2, %i3                                  
4000b06c:	12 bf ff ce 	bne  4000afa4 <_Thread_Dispatch+0x64>          <== ALWAYS TAKEN
4000b070:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        
4000b074:	c0 24 22 b0 	clr  [ %l0 + 0x2b0 ]                           
post_switch:                                                          
  #ifndef RTEMS_SMP                                                   
    _Thread_Dispatch_set_disable_level( 0 );                          
  #endif                                                              
                                                                      
  _ISR_Enable( level );                                               
4000b078:	7f ff dd 1a 	call  400024e0 <sparc_enable_interrupts>       
4000b07c:	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;                    
4000b080:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000b084:	fa 00 63 20 	ld  [ %g1 + 0x320 ], %i5	! 40020320 <_API_extensions_Post_switch_list>
4000b088:	82 10 63 20 	or  %g1, 0x320, %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 ) {                                            
4000b08c:	b8 00 60 04 	add  %g1, 4, %i4                               
4000b090:	80 a7 40 1c 	cmp  %i5, %i4                                  
4000b094:	02 80 00 09 	be  4000b0b8 <_Thread_Dispatch+0x178>          
4000b098:	01 00 00 00 	nop                                            
    const API_extensions_Post_switch_control *post_switch =           
      (const API_extensions_Post_switch_control *) node;              
                                                                      
    (*post_switch->hook)( executing );                                
4000b09c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000b0a0:	9f c0 40 00 	call  %g1                                      
4000b0a4:	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;                                              
4000b0a8:	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 ) {                                            
4000b0ac:	80 a7 40 1c 	cmp  %i5, %i4                                  
4000b0b0:	32 bf ff fc 	bne,a   4000b0a0 <_Thread_Dispatch+0x160>      <== NEVER TAKEN
4000b0b4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           <== NOT EXECUTED
4000b0b8:	81 c7 e0 08 	ret                                            
4000b0bc:	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;            
4000b0c0:	10 bf ff bd 	b  4000afb4 <_Thread_Dispatch+0x74>            
4000b0c4:	c2 26 a0 74 	st  %g1, [ %i2 + 0x74 ]                        
                                                                      

40010704 <_Thread_Handler>: #define INIT_NAME __main #define EXECUTE_GLOBAL_CONSTRUCTORS #endif void _Thread_Handler( void ) {
40010704:	9d e3 bf a0 	save  %sp, -96, %sp                            
  #if defined(EXECUTE_GLOBAL_CONSTRUCTORS)                            
    static bool doneConstructors;                                     
    bool doCons;                                                      
  #endif                                                              
                                                                      
  executing = _Thread_Executing;                                      
40010708:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
4001070c:	fa 00 63 d0 	ld  [ %g1 + 0x3d0 ], %i5	! 400207d0 <_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();                          
40010710:	3f 10 00 41 	sethi  %hi(0x40010400), %i7                    
40010714:	be 17 e3 04 	or  %i7, 0x304, %i7	! 40010704 <_Thread_Handler>
                                                                      
  /*                                                                  
   * have to put level into a register for those cpu's that use       
   * inline asm here                                                  
   */                                                                 
  level = executing->Start.isr_level;                                 
40010718:	d0 07 60 a8 	ld  [ %i5 + 0xa8 ], %o0                        
  _ISR_Set_level(level);                                              
4001071c:	7f ff c7 71 	call  400024e0 <sparc_enable_interrupts>       
40010720:	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;                                     
40010724:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
      doneConstructors = true;                                        
40010728:	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;                                     
4001072c:	f8 08 62 40 	ldub  [ %g1 + 0x240 ], %i4                     
  );                                                                  
}                                                                     
                                                                      
static inline void _User_extensions_Thread_begin( Thread_Control *executing )
{                                                                     
  _User_extensions_Iterate(                                           
40010730:	90 10 00 1d 	mov  %i5, %o0                                  
40010734:	13 10 00 2f 	sethi  %hi(0x4000bc00), %o1                    
40010738:	92 12 60 34 	or  %o1, 0x34, %o1	! 4000bc34 <_User_extensions_Thread_begin_visitor>
4001073c:	7f ff ed 5b 	call  4000bca8 <_User_extensions_Iterate>      
40010740:	c4 28 62 40 	stb  %g2, [ %g1 + 0x240 ]                      
  _User_extensions_Thread_begin( executing );                         
                                                                      
  /*                                                                  
   *  At this point, the dispatch disable level BETTER be 1.          
   */                                                                 
  _Thread_Enable_dispatch();                                          
40010744:	7f ff ea 61 	call  4000b0c8 <_Thread_Enable_dispatch>       
40010748:	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) */ {                    
4001074c:	80 8f 20 ff 	btst  0xff, %i4                                
40010750:	02 80 00 10 	be  40010790 <_Thread_Handler+0x8c>            
40010754:	01 00 00 00 	nop                                            
        _Thread_Enable_dispatch();                                    
      #endif                                                          
    }                                                                 
 #endif                                                               
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
40010758:	c2 07 60 90 	ld  [ %i5 + 0x90 ], %g1                        
4001075c:	80 a0 60 00 	cmp  %g1, 0                                    
40010760:	02 80 00 10 	be  400107a0 <_Thread_Handler+0x9c>            
40010764:	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 ) {  
40010768:	22 80 00 13 	be,a   400107b4 <_Thread_Handler+0xb0>         <== ALWAYS TAKEN
4001076c:	c2 07 60 8c 	ld  [ %i5 + 0x8c ], %g1                        
  }                                                                   
}                                                                     
                                                                      
static inline void _User_extensions_Thread_exitted( Thread_Control *executing )
{                                                                     
  _User_extensions_Iterate(                                           
40010770:	90 10 00 1d 	mov  %i5, %o0                                  
40010774:	13 10 00 2f 	sethi  %hi(0x4000bc00), %o1                    
40010778:	7f ff ed 4c 	call  4000bca8 <_User_extensions_Iterate>      
4001077c:	92 12 60 58 	or  %o1, 0x58, %o1	! 4000bc58 <_User_extensions_Thread_exitted_visitor>
   *  able to fit in a (void *).                                      
   */                                                                 
                                                                      
  _User_extensions_Thread_exitted( executing );                       
                                                                      
  _Internal_error_Occurred(                                           
40010780:	90 10 20 00 	clr  %o0                                       
40010784:	92 10 20 01 	mov  1, %o1                                    
40010788:	7f ff e4 e1 	call  40009b0c <_Internal_error_Occurred>      
4001078c:	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 ();                                                   
40010790:	40 00 3b 42 	call  4001f498 <_init>                         
40010794:	01 00 00 00 	nop                                            
        _Thread_Enable_dispatch();                                    
      #endif                                                          
    }                                                                 
 #endif                                                               
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
40010798:	10 bf ff f1 	b  4001075c <_Thread_Handler+0x58>             
4001079c:	c2 07 60 90 	ld  [ %i5 + 0x90 ], %g1                        
    executing->Wait.return_argument =                                 
      (*(Thread_Entry_numeric) executing->Start.entry_point)(         
400107a0:	c2 07 60 8c 	ld  [ %i5 + 0x8c ], %g1                        
400107a4:	9f c0 40 00 	call  %g1                                      
400107a8:	d0 07 60 98 	ld  [ %i5 + 0x98 ], %o0                        
      #endif                                                          
    }                                                                 
 #endif                                                               
                                                                      
  if ( executing->Start.prototype == THREAD_START_NUMERIC ) {         
    executing->Wait.return_argument =                                 
400107ac:	10 bf ff f1 	b  40010770 <_Thread_Handler+0x6c>             
400107b0:	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)(       
400107b4:	9f c0 40 00 	call  %g1                                      
400107b8:	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 =                               
400107bc:	10 bf ff ed 	b  40010770 <_Thread_Handler+0x6c>             
400107c0:	d0 27 60 28 	st  %o0, [ %i5 + 0x28 ]                        
                                                                      

4000b380 <_Thread_Handler_initialization>: #if defined(RTEMS_SMP) #include <rtems/bspsmp.h> #endif void _Thread_Handler_initialization(void) {
4000b380:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uint32_t ticks_per_timeslice =                                      
4000b384:	03 10 00 75 	sethi  %hi(0x4001d400), %g1                    
4000b388:	82 10 62 18 	or  %g1, 0x218, %g1	! 4001d618 <Configuration> 
  #if defined(RTEMS_MULTIPROCESSING)                                  
    uint32_t maximum_proxies =                                        
      _Configuration_MP_table->maximum_proxies;                       
  #endif                                                              
                                                                      
  if ( rtems_configuration_get_stack_allocate_hook() == NULL ||       
4000b38c:	c6 00 60 28 	ld  [ %g1 + 0x28 ], %g3                        
  #include <rtems/bspsmp.h>                                           
#endif                                                                
                                                                      
void _Thread_Handler_initialization(void)                             
{                                                                     
  uint32_t ticks_per_timeslice =                                      
4000b390:	fa 00 60 14 	ld  [ %g1 + 0x14 ], %i5                        
    rtems_configuration_get_ticks_per_timeslice();                    
  uint32_t maximum_extensions =                                       
4000b394:	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 ||       
4000b398:	80 a0 e0 00 	cmp  %g3, 0                                    
4000b39c:	02 80 00 1f 	be  4000b418 <_Thread_Handler_initialization+0x98><== NEVER TAKEN
4000b3a0:	c4 00 60 24 	ld  [ %g1 + 0x24 ], %g2                        
4000b3a4:	c6 00 60 2c 	ld  [ %g1 + 0x2c ], %g3                        
4000b3a8:	80 a0 e0 00 	cmp  %g3, 0                                    
4000b3ac:	02 80 00 1b 	be  4000b418 <_Thread_Handler_initialization+0x98>
4000b3b0:	80 a0 a0 00 	cmp  %g2, 0                                    
      INTERNAL_ERROR_CORE,                                            
      true,                                                           
      INTERNAL_ERROR_BAD_STACK_HOOK                                   
    );                                                                
                                                                      
  if ( stack_allocate_init_hook != NULL )                             
4000b3b4:	22 80 00 05 	be,a   4000b3c8 <_Thread_Handler_initialization+0x48>
4000b3b8:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
    (*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
4000b3bc:	9f c0 80 00 	call  %g2                                      
4000b3c0:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0	! 40020404 <_CPU_Null_fp_context+0x24>
                                                                      
  _Thread_Dispatch_necessary = false;                                 
4000b3c4:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
4000b3c8:	82 10 63 c0 	or  %g1, 0x3c0, %g1	! 400207c0 <_Per_CPU_Information>
4000b3cc:	c0 28 60 0c 	clrb  [ %g1 + 0xc ]                            
  _Thread_Executing         = NULL;                                   
4000b3d0:	c0 20 60 10 	clr  [ %g1 + 0x10 ]                            
  _Thread_Heir              = NULL;                                   
4000b3d4:	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;                    
4000b3d8:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000b3dc:	f8 20 63 2c 	st  %i4, [ %g1 + 0x32c ]	! 4002032c <_Thread_Maximum_extensions>
                                                                      
  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;                 
4000b3e0:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000b3e4:	fa 20 62 10 	st  %i5, [ %g1 + 0x210 ]	! 40020210 <_Thread_Ticks_per_timeslice>
  #if defined(RTEMS_MULTIPROCESSING)                                  
    if ( _System_state_Is_multiprocessing )                           
      maximum_internal_threads += 1;                                  
  #endif                                                              
                                                                      
  _Objects_Initialize_information(                                    
4000b3e8:	82 10 20 08 	mov  8, %g1                                    
4000b3ec:	11 10 00 80 	sethi  %hi(0x40020000), %o0                    
4000b3f0:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
4000b3f4:	90 12 23 a0 	or  %o0, 0x3a0, %o0                            
4000b3f8:	92 10 20 01 	mov  1, %o1                                    
4000b3fc:	94 10 20 01 	mov  1, %o2                                    
4000b400:	96 10 20 01 	mov  1, %o3                                    
4000b404:	98 10 21 60 	mov  0x160, %o4                                
4000b408:	7f ff fb 6a 	call  4000a1b0 <_Objects_Initialize_information>
4000b40c:	9a 10 20 00 	clr  %o5                                       
4000b410:	81 c7 e0 08 	ret                                            
4000b414:	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(                                         
4000b418:	90 10 20 00 	clr  %o0                                       
4000b41c:	92 10 20 01 	mov  1, %o1                                    
4000b420:	7f ff f9 bb 	call  40009b0c <_Internal_error_Occurred>      
4000b424:	94 10 20 0e 	mov  0xe, %o2                                  
                                                                      

4000b1a4 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) {
4000b1a4:	9d e3 bf 98 	save  %sp, -104, %sp                           
4000b1a8:	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;                             
4000b1ac:	c0 26 61 4c 	clr  [ %i1 + 0x14c ]                           
4000b1b0:	c0 26 61 50 	clr  [ %i1 + 0x150 ]                           
                                                                      
  extensions_area = NULL;                                             
  the_thread->libc_reent = NULL;                                      
4000b1b4:	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                          
)                                                                     
{                                                                     
4000b1b8:	f8 07 a0 60 	ld  [ %fp + 0x60 ], %i4                        
4000b1bc:	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 ) {                                              
4000b1c0:	80 a6 a0 00 	cmp  %i2, 0                                    
4000b1c4:	02 80 00 60 	be  4000b344 <_Thread_Initialize+0x1a0>        
4000b1c8:	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;                 
4000b1cc:	c0 2e 60 b0 	clrb  [ %i1 + 0xb0 ]                           
4000b1d0:	90 10 00 1b 	mov  %i3, %o0                                  
  #endif                                                              
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
4000b1d4:	37 10 00 80 	sethi  %hi(0x40020000), %i3                    
4000b1d8:	c2 06 e3 2c 	ld  [ %i3 + 0x32c ], %g1	! 4002032c <_Thread_Maximum_extensions>
  Stack_Control *the_stack,                                           
  void          *starting_address,                                    
  size_t         size                                                 
)                                                                     
{                                                                     
  the_stack->area = starting_address;                                 
4000b1dc:	f4 26 60 b8 	st  %i2, [ %i1 + 0xb8 ]                        
  the_stack->size = size;                                             
4000b1e0:	d0 26 60 b4 	st  %o0, [ %i1 + 0xb4 ]                        
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
4000b1e4:	c0 26 60 50 	clr  [ %i1 + 0x50 ]                            
  the_watchdog->routine   = routine;                                  
4000b1e8:	c0 26 60 64 	clr  [ %i1 + 0x64 ]                            
  the_watchdog->id        = id;                                       
4000b1ec:	c0 26 60 68 	clr  [ %i1 + 0x68 ]                            
4000b1f0:	80 a0 60 00 	cmp  %g1, 0                                    
4000b1f4:	12 80 00 40 	bne  4000b2f4 <_Thread_Initialize+0x150>       
4000b1f8:	c0 26 60 6c 	clr  [ %i1 + 0x6c ]                            
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
4000b1fc:	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;                                             
4000b200:	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;                
4000b204:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
                                                                      
  /*                                                                  
   *  General initialization                                          
   */                                                                 
                                                                      
  the_thread->Start.is_preemptible   = is_preemptible;                
4000b208:	e2 2e 60 9c 	stb  %l1, [ %i1 + 0x9c ]                       
  the_thread->Start.budget_algorithm = budget_algorithm;              
4000b20c:	f8 26 60 a0 	st  %i4, [ %i1 + 0xa0 ]                        
  the_thread->Start.budget_callout   = budget_callout;                
                                                                      
  switch ( budget_algorithm ) {                                       
4000b210:	80 a7 20 02 	cmp  %i4, 2                                    
4000b214:	12 80 00 05 	bne  4000b228 <_Thread_Initialize+0x84>        
4000b218:	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;    
4000b21c:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000b220:	c2 00 62 10 	ld  [ %g1 + 0x210 ], %g1	! 40020210 <_Thread_Ticks_per_timeslice>
4000b224:	c2 26 60 74 	st  %g1, [ %i1 + 0x74 ]                        
      case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:                       
	break;                                                               
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
4000b228:	c4 07 a0 68 	ld  [ %fp + 0x68 ], %g2                        
 */                                                                   
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(                       
  Thread_Control    *the_thread                                       
)                                                                     
{                                                                     
  return _Scheduler.Operations.allocate( the_thread );                
4000b22c:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
4000b230:	c2 00 61 7c 	ld  [ %g1 + 0x17c ], %g1	! 4001f57c <_Scheduler+0x18>
4000b234:	c4 26 60 a8 	st  %g2, [ %i1 + 0xa8 ]                        
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
4000b238:	b6 10 20 01 	mov  1, %i3                                    
  the_thread->Wait.queue              = NULL;                         
4000b23c:	c0 26 60 44 	clr  [ %i1 + 0x44 ]                            
    #endif                                                            
  }                                                                   
                                                                      
  the_thread->Start.isr_level         = isr_level;                    
                                                                      
  the_thread->current_state           = STATES_DORMANT;               
4000b240:	f6 26 60 10 	st  %i3, [ %i1 + 0x10 ]                        
  the_thread->Wait.queue              = NULL;                         
  the_thread->resource_count          = 0;                            
4000b244:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  the_thread->real_priority           = priority;                     
4000b248:	fa 26 60 18 	st  %i5, [ %i1 + 0x18 ]                        
  the_thread->Start.initial_priority  = priority;                     
4000b24c:	fa 26 60 ac 	st  %i5, [ %i1 + 0xac ]                        
4000b250:	9f c0 40 00 	call  %g1                                      
4000b254:	90 10 00 19 	mov  %i1, %o0                                  
  sched =_Scheduler_Allocate( the_thread );                           
  if ( !sched )                                                       
4000b258:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4000b25c:	22 80 00 17 	be,a   4000b2b8 <_Thread_Initialize+0x114>     
4000b260:	d0 06 61 48 	ld  [ %i1 + 0x148 ], %o0                       
    goto failed;                                                      
  _Thread_Set_priority( the_thread, priority );                       
4000b264:	90 10 00 19 	mov  %i1, %o0                                  
4000b268:	40 00 01 e0 	call  4000b9e8 <_Thread_Set_priority>          
4000b26c:	92 10 00 1d 	mov  %i5, %o1                                  
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
4000b270:	c4 06 20 1c 	ld  [ %i0 + 0x1c ], %g2                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
4000b274:	c2 16 60 0a 	lduh  [ %i1 + 0xa ], %g1                       
                                                                      
static inline void _Timestamp64_implementation_Set_to_zero(           
  Timestamp64_Control *_time                                          
)                                                                     
{                                                                     
  *_time = 0;                                                         
4000b278:	c0 26 60 80 	clr  [ %i1 + 0x80 ]                            
4000b27c:	c0 26 60 84 	clr  [ %i1 + 0x84 ]                            
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
4000b280:	83 28 60 02 	sll  %g1, 2, %g1                               
4000b284:	f2 20 80 01 	st  %i1, [ %g2 + %g1 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
4000b288:	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 };      
4000b28c:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
4000b290:	f6 2f bf fc 	stb  %i3, [ %fp + -4 ]                         
                                                                      
  _User_extensions_Iterate( &ctx, _User_extensions_Thread_create_visitor );
4000b294:	90 07 bf f8 	add  %fp, -8, %o0                              
4000b298:	13 10 00 2e 	sethi  %hi(0x4000b800), %o1                    
4000b29c:	40 00 02 83 	call  4000bca8 <_User_extensions_Iterate>      
4000b2a0:	92 12 63 80 	or  %o1, 0x380, %o1	! 4000bb80 <_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 )                                             
4000b2a4:	c2 0f bf fc 	ldub  [ %fp + -4 ], %g1                        
4000b2a8:	80 a0 60 00 	cmp  %g1, 0                                    
4000b2ac:	12 80 00 0f 	bne  4000b2e8 <_Thread_Initialize+0x144>       
4000b2b0:	b0 10 20 01 	mov  1, %i0                                    
    return true;                                                      
                                                                      
failed:                                                               
  _Workspace_Free( the_thread->libc_reent );                          
4000b2b4:	d0 06 61 48 	ld  [ %i1 + 0x148 ], %o0                       
4000b2b8:	40 00 03 dd 	call  4000c22c <_Workspace_Free>               
4000b2bc:	b0 10 20 00 	clr  %i0                                       
                                                                      
  for ( i=0 ; i <= THREAD_API_LAST ; i++ )                            
    _Workspace_Free( the_thread->API_Extensions[i] );                 
4000b2c0:	40 00 03 db 	call  4000c22c <_Workspace_Free>               
4000b2c4:	d0 06 61 4c 	ld  [ %i1 + 0x14c ], %o0                       
4000b2c8:	40 00 03 d9 	call  4000c22c <_Workspace_Free>               
4000b2cc:	d0 06 61 50 	ld  [ %i1 + 0x150 ], %o0                       
                                                                      
  _Workspace_Free( extensions_area );                                 
4000b2d0:	40 00 03 d7 	call  4000c22c <_Workspace_Free>               
4000b2d4:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
  #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )      
    _Workspace_Free( fp_area );                                       
  #endif                                                              
                                                                      
   _Workspace_Free( sched );                                          
4000b2d8:	40 00 03 d5 	call  4000c22c <_Workspace_Free>               
4000b2dc:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
   _Thread_Stack_Free( the_thread );                                  
4000b2e0:	40 00 01 fb 	call  4000bacc <_Thread_Stack_Free>            
4000b2e4:	90 10 00 19 	mov  %i1, %o0                                  
4000b2e8:	b0 0e 20 ff 	and  %i0, 0xff, %i0                            
4000b2ec:	81 c7 e0 08 	ret                                            
4000b2f0:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  Allocate the extensions area for this thread                    
   */                                                                 
  if ( _Thread_Maximum_extensions ) {                                 
    extensions_area = _Workspace_Allocate(                            
4000b2f4:	90 00 60 01 	add  %g1, 1, %o0                               
4000b2f8:	40 00 03 c5 	call  4000c20c <_Workspace_Allocate>           
4000b2fc:	91 2a 20 02 	sll  %o0, 2, %o0                               
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
4000b300:	b4 92 20 00 	orcc  %o0, 0, %i2                              
4000b304:	02 80 00 1d 	be  4000b378 <_Thread_Initialize+0x1d4>        
4000b308:	86 10 00 1a 	mov  %i2, %g3                                  
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
4000b30c:	f4 26 61 54 	st  %i2, [ %i1 + 0x154 ]                       
4000b310:	c8 06 e3 2c 	ld  [ %i3 + 0x32c ], %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++ )              
4000b314:	84 10 20 00 	clr  %g2                                       
      (_Thread_Maximum_extensions + 1) * sizeof( void * )             
    );                                                                
    if ( !extensions_area )                                           
      goto failed;                                                    
  }                                                                   
  the_thread->extensions = (void **) extensions_area;                 
4000b318:	10 80 00 03 	b  4000b324 <_Thread_Initialize+0x180>         
4000b31c:	82 10 20 00 	clr  %g1                                       
4000b320:	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;                               
4000b324:	85 28 a0 02 	sll  %g2, 2, %g2                               
4000b328:	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++ )              
4000b32c:	82 00 60 01 	inc  %g1                                       
4000b330:	80 a0 40 04 	cmp  %g1, %g4                                  
4000b334:	08 bf ff fb 	bleu  4000b320 <_Thread_Initialize+0x17c>      
4000b338:	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;                
4000b33c:	10 bf ff b3 	b  4000b208 <_Thread_Initialize+0x64>          
4000b340:	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 );
4000b344:	90 10 00 19 	mov  %i1, %o0                                  
4000b348:	40 00 01 d1 	call  4000ba8c <_Thread_Stack_Allocate>        
4000b34c:	92 10 00 1b 	mov  %i3, %o1                                  
      if ( !actual_stack_size || actual_stack_size < stack_size )     
4000b350:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000b354:	0a 80 00 07 	bcs  4000b370 <_Thread_Initialize+0x1cc>       
4000b358:	80 a2 20 00 	cmp  %o0, 0                                    
4000b35c:	02 80 00 05 	be  4000b370 <_Thread_Initialize+0x1cc>        <== NEVER TAKEN
4000b360:	82 10 20 01 	mov  1, %g1                                    
        return false;                     /* stack allocation failed */
                                                                      
      stack = the_thread->Start.stack;                                
4000b364:	f4 06 60 bc 	ld  [ %i1 + 0xbc ], %i2                        
      the_thread->Start.core_allocated_stack = true;                  
4000b368:	10 bf ff 9b 	b  4000b1d4 <_Thread_Initialize+0x30>          
4000b36c:	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 */
4000b370:	10 bf ff de 	b  4000b2e8 <_Thread_Initialize+0x144>         
4000b374:	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;                                  
4000b378:	10 bf ff cf 	b  4000b2b4 <_Thread_Initialize+0x110>         
4000b37c:	b8 10 20 00 	clr  %i4                                       
                                                                      

4000bacc <_Thread_Stack_Free>: #include <rtems/config.h> void _Thread_Stack_Free( Thread_Control *the_thread ) {
4000bacc:	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 )                    
4000bad0:	c2 0e 20 b0 	ldub  [ %i0 + 0xb0 ], %g1                      
4000bad4:	80 a0 60 00 	cmp  %g1, 0                                    
                                                                      
void _Thread_Stack_Free(                                              
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  rtems_stack_free_hook stack_free_hook =                             
4000bad8:	03 10 00 75 	sethi  %hi(0x4001d400), %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 )                    
4000badc:	02 80 00 04 	be  4000baec <_Thread_Stack_Free+0x20>         <== NEVER TAKEN
4000bae0:	c2 00 62 44 	ld  [ %g1 + 0x244 ], %g1	! 4001d644 <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 );         
4000bae4:	9f c0 40 00 	call  %g1                                      
4000bae8:	d0 06 20 b8 	ld  [ %i0 + 0xb8 ], %o0                        
4000baec:	81 c7 e0 08 	ret                                            
4000baf0:	81 e8 00 00 	restore                                        
                                                                      

400107c4 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread ) {
400107c4:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
400107c8:	7f ff c7 42 	call  400024d0 <sparc_disable_interrupts>      <== NOT EXECUTED
400107cc:	01 00 00 00 	nop                                            <== NOT EXECUTED
400107d0:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
400107d4:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        <== NOT EXECUTED
400107d8:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       <== NOT EXECUTED
400107dc:	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 ) ) {
400107e0:	80 88 80 01 	btst  %g2, %g1                                 <== NOT EXECUTED
400107e4:	02 80 00 1a 	be  4001084c <_Thread_queue_Extract_fifo+0x88> <== NOT EXECUTED
400107e8:	01 00 00 00 	nop                                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
400107ec:	c4 06 40 00 	ld  [ %i1 ], %g2                               <== NOT EXECUTED
  previous       = the_node->previous;                                
400107f0:	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 ) ) {                 
400107f4:	c6 06 60 50 	ld  [ %i1 + 0x50 ], %g3                        <== NOT EXECUTED
  next->previous = previous;                                          
400107f8:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
400107fc:	c4 20 40 00 	st  %g2, [ %g1 ]                               <== NOT EXECUTED
40010800:	80 a0 e0 02 	cmp  %g3, 2                                    <== NOT EXECUTED
40010804:	02 80 00 08 	be  40010824 <_Thread_queue_Extract_fifo+0x60> <== NOT EXECUTED
40010808:	c0 26 60 44 	clr  [ %i1 + 0x44 ]                            <== NOT EXECUTED
    _ISR_Enable( level );                                             
4001080c:	7f ff c7 35 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40010810:	b0 10 00 19 	mov  %i1, %i0                                  <== NOT EXECUTED
40010814:	33 04 01 ff 	sethi  %hi(0x1007fc00), %i1                    <== NOT EXECUTED
40010818:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
4001081c:	7f ff e9 3e 	call  4000ad14 <_Thread_Clear_state>           <== NOT EXECUTED
40010820:	81 e8 00 00 	restore                                        <== NOT EXECUTED
40010824:	82 10 20 03 	mov  3, %g1                                    <== NOT EXECUTED
40010828:	c2 26 60 50 	st  %g1, [ %i1 + 0x50 ]                        <== NOT EXECUTED
  } else {                                                            
    _Watchdog_Deactivate( &the_thread->Timer );                       
    _ISR_Enable( level );                                             
4001082c:	7f ff c7 2d 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40010830:	b0 10 00 19 	mov  %i1, %i0                                  <== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );                    
40010834:	7f ff ed c0 	call  4000bf34 <_Watchdog_Remove>              <== NOT EXECUTED
40010838:	90 06 60 48 	add  %i1, 0x48, %o0                            <== NOT EXECUTED
4001083c:	33 04 01 ff 	sethi  %hi(0x1007fc00), %i1                    <== NOT EXECUTED
40010840:	b2 16 63 f8 	or  %i1, 0x3f8, %i1	! 1007fff8 <RAM_SIZE+0xfc7fff8><== NOT EXECUTED
40010844:	7f ff e9 34 	call  4000ad14 <_Thread_Clear_state>           <== NOT EXECUTED
40010848:	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 );                                             
4001084c:	7f ff c7 25 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40010850:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000b928 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) {
4000b928:	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 )                                            
4000b92c:	80 a6 20 00 	cmp  %i0, 0                                    
4000b930:	02 80 00 13 	be  4000b97c <_Thread_queue_Requeue+0x54>      <== NEVER TAKEN
4000b934:	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 ) {
4000b938:	fa 06 20 34 	ld  [ %i0 + 0x34 ], %i5                        
4000b93c:	80 a7 60 01 	cmp  %i5, 1                                    
4000b940:	02 80 00 04 	be  4000b950 <_Thread_queue_Requeue+0x28>      <== ALWAYS TAKEN
4000b944:	01 00 00 00 	nop                                            
4000b948:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000b94c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    Thread_queue_Control *tq = the_thread_queue;                      
    ISR_Level             level;                                      
    ISR_Level             level_ignored;                              
                                                                      
    _ISR_Disable( level );                                            
4000b950:	7f ff da e0 	call  400024d0 <sparc_disable_interrupts>      
4000b954:	01 00 00 00 	nop                                            
4000b958:	b8 10 00 08 	mov  %o0, %i4                                  
4000b95c:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
4000b960:	03 00 00 ef 	sethi  %hi(0x3bc00), %g1                       
4000b964:	82 10 62 e0 	or  %g1, 0x2e0, %g1	! 3bee0 <PROM_START+0x3bee0>
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000b968:	80 88 80 01 	btst  %g2, %g1                                 
4000b96c:	12 80 00 06 	bne  4000b984 <_Thread_queue_Requeue+0x5c>     <== ALWAYS TAKEN
4000b970:	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 );                                             
4000b974:	7f ff da db 	call  400024e0 <sparc_enable_interrupts>       
4000b978:	90 10 00 1c 	mov  %i4, %o0                                  
4000b97c:	81 c7 e0 08 	ret                                            
4000b980:	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 );  
4000b984:	92 10 00 19 	mov  %i1, %o1                                  
4000b988:	94 10 20 01 	mov  1, %o2                                    
4000b98c:	40 00 0c c8 	call  4000ecac <_Thread_queue_Extract_priority_helper>
4000b990:	fa 26 20 30 	st  %i5, [ %i0 + 0x30 ]                        
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
4000b994:	90 10 00 18 	mov  %i0, %o0                                  
4000b998:	92 10 00 19 	mov  %i1, %o1                                  
4000b99c:	7f ff ff 35 	call  4000b670 <_Thread_queue_Enqueue_priority>
4000b9a0:	94 07 bf fc 	add  %fp, -4, %o2                              
4000b9a4:	30 bf ff f4 	b,a   4000b974 <_Thread_queue_Requeue+0x4c>    
                                                                      

4000b9a8 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) {
4000b9a8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control       *the_thread;                                   
  Objects_Locations     location;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000b9ac:	90 10 00 18 	mov  %i0, %o0                                  
4000b9b0:	7f ff fd d2 	call  4000b0f8 <_Thread_Get>                   
4000b9b4:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000b9b8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000b9bc:	80 a0 60 00 	cmp  %g1, 0                                    
4000b9c0:	12 80 00 08 	bne  4000b9e0 <_Thread_queue_Timeout+0x38>     <== NEVER TAKEN
4000b9c4:	01 00 00 00 	nop                                            
#if defined(RTEMS_MULTIPROCESSING)                                    
    case OBJECTS_REMOTE:  /* impossible */                            
#endif                                                                
      break;                                                          
    case OBJECTS_LOCAL:                                               
      _Thread_queue_Process_timeout( the_thread );                    
4000b9c8:	40 00 0c f2 	call  4000ed90 <_Thread_queue_Process_timeout> 
4000b9cc:	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;                  
4000b9d0:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000b9d4:	c4 00 62 b0 	ld  [ %g1 + 0x2b0 ], %g2	! 400202b0 <_Thread_Dispatch_disable_level>
                                                                      
    --level;                                                          
4000b9d8:	84 00 bf ff 	add  %g2, -1, %g2                              
    _Thread_Dispatch_disable_level = level;                           
4000b9dc:	c4 20 62 b0 	st  %g2, [ %g1 + 0x2b0 ]                       
4000b9e0:	81 c7 e0 08 	ret                                            
4000b9e4:	81 e8 00 00 	restore                                        
                                                                      

40018af0 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) {
40018af0:	9d e3 bf 88 	save  %sp, -120, %sp                           
40018af4:	21 10 00 fa 	sethi  %hi(0x4003e800), %l0                    
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40018af8:	a4 07 bf e8 	add  %fp, -24, %l2                             
40018afc:	b4 07 bf ec 	add  %fp, -20, %i2                             
40018b00:	b8 07 bf f4 	add  %fp, -12, %i4                             
40018b04:	a2 07 bf f8 	add  %fp, -8, %l1                              
40018b08:	33 10 00 f9 	sethi  %hi(0x4003e400), %i1                    
40018b0c:	27 10 00 fa 	sethi  %hi(0x4003e800), %l3                    
40018b10:	f4 27 bf e8 	st  %i2, [ %fp + -24 ]                         
  head->previous = NULL;                                              
40018b14:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  tail->previous = head;                                              
40018b18:	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;                                                  
40018b1c:	e2 27 bf f4 	st  %l1, [ %fp + -12 ]                         
  head->previous = NULL;                                              
40018b20:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  tail->previous = head;                                              
40018b24:	f8 27 bf fc 	st  %i4, [ %fp + -4 ]                          
40018b28:	a0 14 21 48 	or  %l0, 0x148, %l0                            
40018b2c:	b6 06 20 30 	add  %i0, 0x30, %i3                            
40018b30:	b2 16 63 a8 	or  %i1, 0x3a8, %i1                            
40018b34:	ba 06 20 68 	add  %i0, 0x68, %i5                            
40018b38:	a6 14 e0 60 	or  %l3, 0x60, %l3                             
40018b3c:	ac 06 20 08 	add  %i0, 8, %l6                               
40018b40:	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;                                              
40018b44:	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;                                    
40018b48:	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;            
40018b4c:	c2 04 00 00 	ld  [ %l0 ], %g1                               
                                                                      
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
40018b50:	d2 06 20 3c 	ld  [ %i0 + 0x3c ], %o1                        
                                                                      
  watchdogs->last_snapshot = snapshot;                                
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
40018b54:	90 10 00 1b 	mov  %i3, %o0                                  
40018b58:	92 20 40 09 	sub  %g1, %o1, %o1                             
40018b5c:	94 10 00 1c 	mov  %i4, %o2                                  
  /*                                                                  
   *  We assume adequate unsigned arithmetic here.                    
   */                                                                 
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;      
                                                                      
  watchdogs->last_snapshot = snapshot;                                
40018b60:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
                                                                      
  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );  
40018b64:	40 00 12 35 	call  4001d438 <_Watchdog_Adjust_to_chain>     
40018b68:	01 00 00 00 	nop                                            
40018b6c:	d0 1e 40 00 	ldd  [ %i1 ], %o0                              
40018b70:	94 10 20 00 	clr  %o2                                       
40018b74:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40018b78:	40 00 51 6b 	call  4002d124 <__divdi3>                      
40018b7c:	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;         
40018b80:	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 ) {                                   
40018b84:	80 a2 40 0a 	cmp  %o1, %o2                                  
40018b88:	18 80 00 2b 	bgu  40018c34 <_Timer_server_Body+0x144>       
40018b8c:	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 ) {                            
40018b90:	80 a2 40 0a 	cmp  %o1, %o2                                  
40018b94:	0a 80 00 20 	bcs  40018c14 <_Timer_server_Body+0x124>       
40018b98:	90 10 00 1d 	mov  %i5, %o0                                  
      */                                                              
     delta = last_snapshot - snapshot;                                
     _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 
  }                                                                   
                                                                      
  watchdogs->last_snapshot = snapshot;                                
40018b9c:	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 );
40018ba0:	d0 06 20 78 	ld  [ %i0 + 0x78 ], %o0                        
40018ba4:	40 00 02 c2 	call  400196ac <_Chain_Get>                    
40018ba8:	01 00 00 00 	nop                                            
                                                                      
    if ( timer == NULL ) {                                            
40018bac:	92 92 20 00 	orcc  %o0, 0, %o1                              
40018bb0:	02 80 00 10 	be  40018bf0 <_Timer_server_Body+0x100>        
40018bb4:	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 ) {                 
40018bb8:	c2 02 60 38 	ld  [ %o1 + 0x38 ], %g1                        
40018bbc:	80 a0 60 01 	cmp  %g1, 1                                    
40018bc0:	02 80 00 19 	be  40018c24 <_Timer_server_Body+0x134>        
40018bc4:	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 ) {       
40018bc8:	12 bf ff f6 	bne  40018ba0 <_Timer_server_Body+0xb0>        <== NEVER TAKEN
40018bcc:	92 02 60 10 	add  %o1, 0x10, %o1                            
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
40018bd0:	40 00 12 46 	call  4001d4e8 <_Watchdog_Insert>              
40018bd4:	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 );
40018bd8:	d0 06 20 78 	ld  [ %i0 + 0x78 ], %o0                        
40018bdc:	40 00 02 b4 	call  400196ac <_Chain_Get>                    
40018be0:	01 00 00 00 	nop                                            
                                                                      
    if ( timer == NULL ) {                                            
40018be4:	92 92 20 00 	orcc  %o0, 0, %o1                              
40018be8:	32 bf ff f5 	bne,a   40018bbc <_Timer_server_Body+0xcc>     <== NEVER TAKEN
40018bec:	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 );                                            
40018bf0:	7f ff da 73 	call  4000f5bc <sparc_disable_interrupts>      
40018bf4:	01 00 00 00 	nop                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
40018bf8:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
40018bfc:	80 a0 40 1a 	cmp  %g1, %i2                                  
40018c00:	02 80 00 12 	be  40018c48 <_Timer_server_Body+0x158>        <== ALWAYS TAKEN
40018c04:	01 00 00 00 	nop                                            
      ts->insert_chain = NULL;                                        
      _ISR_Enable( level );                                           
                                                                      
      break;                                                          
    } else {                                                          
      _ISR_Enable( level );                                           
40018c08:	7f ff da 71 	call  4000f5cc <sparc_enable_interrupts>       <== NOT EXECUTED
40018c0c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40018c10:	30 bf ff cf 	b,a   40018b4c <_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 ); 
40018c14:	92 10 20 01 	mov  1, %o1	! 1 <PROM_START+0x1>               
40018c18:	40 00 11 d8 	call  4001d378 <_Watchdog_Adjust>              
40018c1c:	94 22 80 17 	sub  %o2, %l7, %o2                             
40018c20:	30 bf ff df 	b,a   40018b9c <_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 );
40018c24:	90 10 00 1b 	mov  %i3, %o0                                  
40018c28:	40 00 12 30 	call  4001d4e8 <_Watchdog_Insert>              
40018c2c:	92 02 60 10 	add  %o1, 0x10, %o1                            
40018c30:	30 bf ff dc 	b,a   40018ba0 <_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 );
40018c34:	92 22 40 0a 	sub  %o1, %o2, %o1                             
40018c38:	90 10 00 1d 	mov  %i5, %o0                                  
40018c3c:	40 00 11 ff 	call  4001d438 <_Watchdog_Adjust_to_chain>     
40018c40:	94 10 00 1c 	mov  %i4, %o2                                  
40018c44:	30 bf ff d6 	b,a   40018b9c <_Timer_server_Body+0xac>       
     */                                                               
    _Timer_server_Process_insertions( ts );                           
                                                                      
    _ISR_Disable( level );                                            
    if ( _Chain_Is_empty( insert_chain ) ) {                          
      ts->insert_chain = NULL;                                        
40018c48:	c0 26 20 78 	clr  [ %i0 + 0x78 ]                            
      _ISR_Enable( level );                                           
40018c4c:	7f ff da 60 	call  4000f5cc <sparc_enable_interrupts>       
40018c50:	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 ) ) {                          
40018c54:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40018c58:	80 a0 40 11 	cmp  %g1, %l1                                  
40018c5c:	12 80 00 0c 	bne  40018c8c <_Timer_server_Body+0x19c>       
40018c60:	01 00 00 00 	nop                                            
40018c64:	30 80 00 13 	b,a   40018cb0 <_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;                                         
40018c68:	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;                                             
40018c6c:	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;                        
40018c70:	c0 25 e0 08 	clr  [ %l7 + 8 ]                               
          _ISR_Enable( level );                                       
40018c74:	7f ff da 56 	call  4000f5cc <sparc_enable_interrupts>       
40018c78:	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 );    
40018c7c:	d0 05 e0 20 	ld  [ %l7 + 0x20 ], %o0                        
40018c80:	c2 05 e0 1c 	ld  [ %l7 + 0x1c ], %g1                        
40018c84:	9f c0 40 00 	call  %g1                                      
40018c88:	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 );                                        
40018c8c:	7f ff da 4c 	call  4000f5bc <sparc_disable_interrupts>      
40018c90:	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;                    
40018c94:	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))                                   
40018c98:	80 a5 c0 11 	cmp  %l7, %l1                                  
40018c9c:	32 bf ff f3 	bne,a   40018c68 <_Timer_server_Body+0x178>    
40018ca0:	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 );                                       
40018ca4:	7f ff da 4a 	call  4000f5cc <sparc_enable_interrupts>       
40018ca8:	01 00 00 00 	nop                                            
40018cac:	30 bf ff a7 	b,a   40018b48 <_Timer_server_Body+0x58>       
         *  the active flag of the timer server is true.              
         */                                                           
        (*watchdog->routine)( watchdog->id, watchdog->user_data );    
      }                                                               
    } else {                                                          
      ts->active = false;                                             
40018cb0:	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;                  
40018cb4:	c2 04 c0 00 	ld  [ %l3 ], %g1                               
                                                                      
    ++level;                                                          
40018cb8:	82 00 60 01 	inc  %g1                                       
    _Thread_Dispatch_disable_level = level;                           
40018cbc:	c2 24 c0 00 	st  %g1, [ %l3 ]                               
                                                                      
      /*                                                              
       *  Block until there is something to do.                       
       */                                                             
      _Thread_Disable_dispatch();                                     
        _Thread_Set_state( ts->thread, STATES_DELAYING );             
40018cc0:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40018cc4:	40 00 10 c1 	call  4001cfc8 <_Thread_Set_state>             
40018cc8:	92 10 20 08 	mov  8, %o1                                    
        _Timer_server_Reset_interval_system_watchdog( ts );           
40018ccc:	7f ff ff 07 	call  400188e8 <_Timer_server_Reset_interval_system_watchdog>
40018cd0:	90 10 00 18 	mov  %i0, %o0                                  
        _Timer_server_Reset_tod_system_watchdog( ts );                
40018cd4:	7f ff ff 19 	call  40018938 <_Timer_server_Reset_tod_system_watchdog>
40018cd8:	90 10 00 18 	mov  %i0, %o0                                  
      _Thread_Enable_dispatch();                                      
40018cdc:	40 00 0e 4d 	call  4001c610 <_Thread_Enable_dispatch>       
40018ce0:	01 00 00 00 	nop                                            
                                                                      
static void _Timer_server_Stop_interval_system_watchdog(              
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );        
40018ce4:	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;                                              
40018ce8:	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 );        
40018cec:	40 00 12 5e 	call  4001d664 <_Watchdog_Remove>              
40018cf0:	01 00 00 00 	nop                                            
                                                                      
static void _Timer_server_Stop_tod_system_watchdog(                   
  Timer_server_Control *ts                                            
)                                                                     
{                                                                     
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );             
40018cf4:	40 00 12 5c 	call  4001d664 <_Watchdog_Remove>              
40018cf8:	90 10 00 15 	mov  %l5, %o0                                  
40018cfc:	30 bf ff 93 	b,a   40018b48 <_Timer_server_Body+0x58>       
                                                                      

40018988 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) {
40018988:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( ts->insert_chain == NULL ) {                                   
4001898c:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        
40018990:	80 a0 60 00 	cmp  %g1, 0                                    
40018994:	02 80 00 05 	be  400189a8 <_Timer_server_Schedule_operation_method+0x20>
40018998:	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 );           
4001899c:	f0 06 20 78 	ld  [ %i0 + 0x78 ], %i0                        
400189a0:	40 00 03 38 	call  40019680 <_Chain_Append>                 
400189a4:	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;                  
400189a8:	03 10 00 fa 	sethi  %hi(0x4003e800), %g1                    
400189ac:	c4 00 60 60 	ld  [ %g1 + 0x60 ], %g2	! 4003e860 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
400189b0:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
400189b4:	c4 20 60 60 	st  %g2, [ %g1 + 0x60 ]                        
   *  being inserted.  This could result in an integer overflow.      
   */                                                                 
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {                 
400189b8:	c2 06 60 38 	ld  [ %i1 + 0x38 ], %g1                        
400189bc:	80 a0 60 01 	cmp  %g1, 1                                    
400189c0:	02 80 00 2b 	be  40018a6c <_Timer_server_Schedule_operation_method+0xe4>
400189c4:	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 ) {       
400189c8:	02 80 00 04 	be  400189d8 <_Timer_server_Schedule_operation_method+0x50>
400189cc:	01 00 00 00 	nop                                            
    if ( !ts->active ) {                                              
      _Timer_server_Reset_tod_system_watchdog( ts );                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
400189d0:	40 00 0f 10 	call  4001c610 <_Thread_Enable_dispatch>       
400189d4:	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 );                                            
400189d8:	7f ff da f9 	call  4000f5bc <sparc_disable_interrupts>      
400189dc:	01 00 00 00 	nop                                            
400189e0:	b8 10 00 08 	mov  %o0, %i4                                  
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();        
400189e4:	03 10 00 f9 	sethi  %hi(0x4003e400), %g1                    
400189e8:	d0 18 63 a8 	ldd  [ %g1 + 0x3a8 ], %o0	! 4003e7a8 <_TOD>    
400189ec:	94 10 20 00 	clr  %o2                                       
400189f0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400189f4:	40 00 51 cc 	call  4002d124 <__divdi3>                      
400189f8:	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;                    
400189fc:	c2 06 20 68 	ld  [ %i0 + 0x68 ], %g1                        
    last_snapshot = ts->TOD_watchdogs.last_snapshot;                  
40018a00:	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 );                            
40018a04:	86 06 20 6c 	add  %i0, 0x6c, %g3                            
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {             
40018a08:	80 a0 40 03 	cmp  %g1, %g3                                  
40018a0c:	02 80 00 0a 	be  40018a34 <_Timer_server_Schedule_operation_method+0xac>
40018a10:	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 ) {                               
40018a14:	08 80 00 34 	bleu  40018ae4 <_Timer_server_Schedule_operation_method+0x15c>
40018a18:	c8 00 60 10 	ld  [ %g1 + 0x10 ], %g4                        
        /*                                                            
         *  We advanced in time.                                      
         */                                                           
        delta = snapshot - last_snapshot;                             
40018a1c:	84 22 40 02 	sub  %o1, %g2, %g2                             
        if (delta_interval > delta) {                                 
40018a20:	80 a1 00 02 	cmp  %g4, %g2                                  
40018a24:	08 80 00 03 	bleu  40018a30 <_Timer_server_Schedule_operation_method+0xa8><== NEVER TAKEN
40018a28:	86 10 20 00 	clr  %g3                                       
          delta_interval -= delta;                                    
40018a2c:	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;                
40018a30:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
    }                                                                 
    ts->TOD_watchdogs.last_snapshot = snapshot;                       
40018a34:	d2 26 20 74 	st  %o1, [ %i0 + 0x74 ]                        
    _ISR_Enable( level );                                             
40018a38:	7f ff da e5 	call  4000f5cc <sparc_enable_interrupts>       
40018a3c:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );     
40018a40:	90 06 20 68 	add  %i0, 0x68, %o0                            
40018a44:	40 00 12 a9 	call  4001d4e8 <_Watchdog_Insert>              
40018a48:	92 07 60 10 	add  %i5, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
40018a4c:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
40018a50:	80 a0 60 00 	cmp  %g1, 0                                    
40018a54:	12 bf ff df 	bne  400189d0 <_Timer_server_Schedule_operation_method+0x48>
40018a58:	01 00 00 00 	nop                                            
      _Timer_server_Reset_tod_system_watchdog( ts );                  
40018a5c:	7f ff ff b7 	call  40018938 <_Timer_server_Reset_tod_system_watchdog>
40018a60:	90 10 00 18 	mov  %i0, %o0                                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
40018a64:	40 00 0e eb 	call  4001c610 <_Thread_Enable_dispatch>       
40018a68:	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 );                                            
40018a6c:	7f ff da d4 	call  4000f5bc <sparc_disable_interrupts>      
40018a70:	01 00 00 00 	nop                                            
    snapshot = _Watchdog_Ticks_since_boot;                            
40018a74:	05 10 00 fa 	sethi  %hi(0x4003e800), %g2                    
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
40018a78:	c2 06 20 30 	ld  [ %i0 + 0x30 ], %g1                        
40018a7c:	c4 00 a1 48 	ld  [ %g2 + 0x148 ], %g2                       
    last_snapshot = ts->Interval_watchdogs.last_snapshot;             
40018a80:	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 );                            
40018a84:	86 06 20 34 	add  %i0, 0x34, %g3                            
    if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {        
40018a88:	80 a0 40 03 	cmp  %g1, %g3                                  
40018a8c:	02 80 00 08 	be  40018aac <_Timer_server_Schedule_operation_method+0x124>
40018a90:	88 20 80 04 	sub  %g2, %g4, %g4                             
      /*                                                              
       *  We assume adequate unsigned arithmetic here.                
       */                                                             
      delta = snapshot - last_snapshot;                               
                                                                      
      delta_interval = first_watchdog->delta_interval;                
40018a94:	f8 00 60 10 	ld  [ %g1 + 0x10 ], %i4                        
      if (delta_interval > delta) {                                   
40018a98:	80 a1 00 1c 	cmp  %g4, %i4                                  
40018a9c:	1a 80 00 03 	bcc  40018aa8 <_Timer_server_Schedule_operation_method+0x120>
40018aa0:	86 10 20 00 	clr  %g3                                       
        delta_interval -= delta;                                      
40018aa4:	86 27 00 04 	sub  %i4, %g4, %g3                             
      } else {                                                        
        delta_interval = 0;                                           
      }                                                               
      first_watchdog->delta_interval = delta_interval;                
40018aa8:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
    }                                                                 
    ts->Interval_watchdogs.last_snapshot = snapshot;                  
40018aac:	c4 26 20 3c 	st  %g2, [ %i0 + 0x3c ]                        
    _ISR_Enable( level );                                             
40018ab0:	7f ff da c7 	call  4000f5cc <sparc_enable_interrupts>       
40018ab4:	01 00 00 00 	nop                                            
                                                                      
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
40018ab8:	90 06 20 30 	add  %i0, 0x30, %o0                            
40018abc:	40 00 12 8b 	call  4001d4e8 <_Watchdog_Insert>              
40018ac0:	92 07 60 10 	add  %i5, 0x10, %o1                            
                                                                      
    if ( !ts->active ) {                                              
40018ac4:	c2 0e 20 7c 	ldub  [ %i0 + 0x7c ], %g1                      
40018ac8:	80 a0 60 00 	cmp  %g1, 0                                    
40018acc:	12 bf ff c1 	bne  400189d0 <_Timer_server_Schedule_operation_method+0x48>
40018ad0:	01 00 00 00 	nop                                            
      _Timer_server_Reset_interval_system_watchdog( ts );             
40018ad4:	7f ff ff 85 	call  400188e8 <_Timer_server_Reset_interval_system_watchdog>
40018ad8:	90 10 00 18 	mov  %i0, %o0                                  
    if ( !ts->active ) {                                              
      _Timer_server_Reset_tod_system_watchdog( ts );                  
    }                                                                 
  }                                                                   
                                                                      
  _Thread_Enable_dispatch();                                          
40018adc:	40 00 0e cd 	call  4001c610 <_Thread_Enable_dispatch>       
40018ae0:	81 e8 00 00 	restore                                        
        }                                                             
      } else {                                                        
        /*                                                            
         *  Someone put us in the past.                               
         */                                                           
        delta = last_snapshot - snapshot;                             
40018ae4:	84 01 00 02 	add  %g4, %g2, %g2                             
        delta_interval += delta;                                      
40018ae8:	10 bf ff d2 	b  40018a30 <_Timer_server_Schedule_operation_method+0xa8>
40018aec:	86 20 80 09 	sub  %g2, %o1, %g3                             
                                                                      

4000d698 <_Timespec_Add_to>: ) { uint32_t seconds = add->tv_sec; /* Add the basics */ time->tv_sec += add->tv_sec;
4000d698:	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;                                     
4000d69c:	c4 02 40 00 	ld  [ %o1 ], %g2                               
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
  time->tv_nsec += add->tv_nsec;                                      
4000d6a0:	c6 02 20 04 	ld  [ %o0 + 4 ], %g3                           
4000d6a4:	c2 02 60 04 	ld  [ %o1 + 4 ], %g1                           
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
4000d6a8:	98 03 00 02 	add  %o4, %g2, %o4                             
  time->tv_nsec += add->tv_nsec;                                      
4000d6ac:	82 00 c0 01 	add  %g3, %g1, %g1                             
)                                                                     
{                                                                     
  uint32_t seconds = add->tv_sec;                                     
                                                                      
  /* Add the basics */                                                
  time->tv_sec += add->tv_sec;                                        
4000d6b0:	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 ) {             
4000d6b4:	09 0e e6 b2 	sethi  %hi(0x3b9ac800), %g4                    
4000d6b8:	88 11 21 ff 	or  %g4, 0x1ff, %g4	! 3b9ac9ff <RAM_SIZE+0x3b5ac9ff>
4000d6bc:	80 a0 40 04 	cmp  %g1, %g4                                  
4000d6c0:	08 80 00 0d 	bleu  4000d6f4 <_Timespec_Add_to+0x5c>         
4000d6c4:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
4000d6c8:	98 03 20 01 	inc  %o4                                       
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                      
4000d6cc:	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(                                            
4000d6d0:	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;                      
4000d6d4:	9a 13 62 00 	or  %o5, 0x200, %o5                            
4000d6d8:	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(                                            
4000d6dc:	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 ) {             
4000d6e0:	80 a0 40 04 	cmp  %g1, %g4                                  
4000d6e4:	18 bf ff fd 	bgu  4000d6d8 <_Timespec_Add_to+0x40>          <== NEVER TAKEN
4000d6e8:	84 00 a0 01 	inc  %g2                                       
4000d6ec:	c2 22 20 04 	st  %g1, [ %o0 + 4 ]                           
4000d6f0:	c6 22 00 00 	st  %g3, [ %o0 ]                               
    time->tv_sec++;                                                   
    seconds++;                                                        
  }                                                                   
                                                                      
  return seconds;                                                     
}                                                                     
4000d6f4:	81 c3 e0 08 	retl                                           
4000d6f8:	90 10 00 02 	mov  %g2, %o0                                  
                                                                      

4000d430 <_Timestamp64_Divide>: const Timestamp64_Control *_lhs, const Timestamp64_Control *_rhs, uint32_t *_ival_percentage, uint32_t *_fval_percentage ) {
4000d430:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Timestamp64_Control answer;                                         
                                                                      
  if ( *_rhs == 0 ) {                                                 
4000d434:	d4 1e 40 00 	ldd  [ %i1 ], %o2                              
4000d438:	80 92 80 0b 	orcc  %o2, %o3, %g0                            
4000d43c:	22 80 00 2f 	be,a   4000d4f8 <_Timestamp64_Divide+0xc8>     <== NEVER TAKEN
4000d440:	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;                                  
4000d444:	e0 1e 00 00 	ldd  [ %i0 ], %l0                              
4000d448:	83 2c 20 02 	sll  %l0, 2, %g1                               
4000d44c:	89 34 60 1e 	srl  %l1, 0x1e, %g4                            
4000d450:	87 2c 60 02 	sll  %l1, 2, %g3                               
4000d454:	84 11 00 01 	or  %g4, %g1, %g2                              
4000d458:	83 30 e0 1b 	srl  %g3, 0x1b, %g1                            
4000d45c:	9b 28 e0 05 	sll  %g3, 5, %o5                               
4000d460:	99 28 a0 05 	sll  %g2, 5, %o4                               
4000d464:	86 a3 40 03 	subcc  %o5, %g3, %g3                           
4000d468:	98 10 40 0c 	or  %g1, %o4, %o4                              
4000d46c:	84 63 00 02 	subx  %o4, %g2, %g2                            
4000d470:	92 80 c0 11 	addcc  %g3, %l1, %o1                           
4000d474:	83 32 60 1e 	srl  %o1, 0x1e, %g1                            
4000d478:	90 40 80 10 	addx  %g2, %l0, %o0                            
4000d47c:	b3 2a 60 02 	sll  %o1, 2, %i1                               
4000d480:	b1 2a 20 02 	sll  %o0, 2, %i0                               
4000d484:	86 82 40 19 	addcc  %o1, %i1, %g3                           
4000d488:	b0 10 40 18 	or  %g1, %i0, %i0                              
4000d48c:	83 30 e0 1e 	srl  %g3, 0x1e, %g1                            
4000d490:	84 42 00 18 	addx  %o0, %i0, %g2                            
4000d494:	bb 28 e0 02 	sll  %g3, 2, %i5                               
4000d498:	b9 28 a0 02 	sll  %g2, 2, %i4                               
4000d49c:	92 80 c0 1d 	addcc  %g3, %i5, %o1                           
4000d4a0:	b8 10 40 1c 	or  %g1, %i4, %i4                              
4000d4a4:	87 32 60 1b 	srl  %o1, 0x1b, %g3                            
4000d4a8:	90 40 80 1c 	addx  %g2, %i4, %o0                            
4000d4ac:	83 2a 60 05 	sll  %o1, 5, %g1                               
4000d4b0:	85 2a 20 05 	sll  %o0, 5, %g2                               
4000d4b4:	92 10 00 01 	mov  %g1, %o1                                  
4000d4b8:	40 00 3b 32 	call  4001c180 <__divdi3>                      
4000d4bc:	90 10 c0 02 	or  %g3, %g2, %o0                              
                                                                      
  *_ival_percentage = answer / 1000;                                  
4000d4c0:	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;                                  
4000d4c4:	b8 10 00 08 	mov  %o0, %i4                                  
4000d4c8:	ba 10 00 09 	mov  %o1, %i5                                  
                                                                      
  *_ival_percentage = answer / 1000;                                  
4000d4cc:	40 00 3b 2d 	call  4001c180 <__divdi3>                      
4000d4d0:	96 10 23 e8 	mov  0x3e8, %o3                                
  *_fval_percentage = answer % 1000;                                  
4000d4d4:	90 10 00 1c 	mov  %i4, %o0                                  
   *  TODO: Rounding on the last digit of the fval.                   
   */                                                                 
                                                                      
  answer = (*_lhs * 100000) / *_rhs;                                  
                                                                      
  *_ival_percentage = answer / 1000;                                  
4000d4d8:	d2 26 80 00 	st  %o1, [ %i2 ]                               
  *_fval_percentage = answer % 1000;                                  
4000d4dc:	94 10 20 00 	clr  %o2                                       
4000d4e0:	96 10 23 e8 	mov  0x3e8, %o3                                
4000d4e4:	40 00 3c 12 	call  4001c52c <__moddi3>                      
4000d4e8:	92 10 00 1d 	mov  %i5, %o1                                  
4000d4ec:	d2 26 c0 00 	st  %o1, [ %i3 ]                               
4000d4f0:	81 c7 e0 08 	ret                                            
4000d4f4:	81 e8 00 00 	restore                                        
{                                                                     
  Timestamp64_Control answer;                                         
                                                                      
  if ( *_rhs == 0 ) {                                                 
    *_ival_percentage = 0;                                            
    *_fval_percentage = 0;                                            
4000d4f8:	c0 26 c0 00 	clr  [ %i3 ]                                   <== NOT EXECUTED
    return;                                                           
4000d4fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000d500:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000bd78 <_User_extensions_Handler_initialization>: } } void _User_extensions_Handler_initialization(void) {
4000bd78:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uint32_t number_of_initial_extensions =                             
4000bd7c:	03 10 00 75 	sethi  %hi(0x4001d400), %g1                    
4000bd80:	c2 00 62 58 	ld  [ %g1 + 0x258 ], %g1	! 4001d658 <Configuration+0x40>
    rtems_configuration_get_number_of_initial_extensions();           
                                                                      
  if ( number_of_initial_extensions > 0 ) {                           
4000bd84:	80 a0 60 00 	cmp  %g1, 0                                    
4000bd88:	02 80 00 0a 	be  4000bdb0 <_User_extensions_Handler_initialization+0x38><== NEVER TAKEN
4000bd8c:	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 )              
4000bd90:	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 =
4000bd94:	40 00 01 2c 	call  4000c244 <_Workspace_Allocate_or_fatal_error>
4000bd98:	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 );
4000bd9c:	13 10 00 2f 	sethi  %hi(0x4000bc00), %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 };
4000bda0:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
                                                                      
    _User_extensions_Iterate( &ctx, _User_extensions_Switch_visitor );
4000bda4:	92 12 61 34 	or  %o1, 0x134, %o1                            
4000bda8:	7f ff ff c0 	call  4000bca8 <_User_extensions_Iterate>      
4000bdac:	90 07 bf fc 	add  %fp, -4, %o0                              
4000bdb0:	81 c7 e0 08 	ret                                            
4000bdb4:	81 e8 00 00 	restore                                        
                                                                      

4000bca8 <_User_extensions_Iterate>: void _User_extensions_Iterate( void *arg, User_extensions_Visitor visitor ) {
4000bca8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Thread_Control   *executing = _Thread_Executing;                    
  const User_extensions_Table *callouts_current =                     
4000bcac:	03 10 00 75 	sethi  %hi(0x4001d400), %g1                    
4000bcb0:	82 10 62 18 	or  %g1, 0x218, %g1	! 4001d618 <Configuration> 
4000bcb4:	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();
4000bcb8:	f6 00 60 40 	ld  [ %g1 + 0x40 ], %i3                        
void _User_extensions_Iterate(                                        
  void                    *arg,                                       
  User_extensions_Visitor  visitor                                    
)                                                                     
{                                                                     
  Thread_Control   *executing = _Thread_Executing;                    
4000bcbc:	03 10 00 81 	sethi  %hi(0x40020400), %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();
4000bcc0:	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 =                         
4000bcc4:	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 ) {                        
4000bcc8:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000bccc:	02 80 00 0a 	be  4000bcf4 <_User_extensions_Iterate+0x4c>   <== NEVER TAKEN
4000bcd0:	f8 00 63 d0 	ld  [ %g1 + 0x3d0 ], %i4                       
    (*visitor)( executing, arg, callouts_current );                   
4000bcd4:	94 10 00 1d 	mov  %i5, %o2                                  
4000bcd8:	90 10 00 1c 	mov  %i4, %o0                                  
4000bcdc:	9f c6 40 00 	call  %i1                                      
4000bce0:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
    ++callouts_current;                                               
4000bce4:	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 ) {                        
4000bce8:	80 a6 c0 1d 	cmp  %i3, %i5                                  
4000bcec:	12 bf ff fb 	bne  4000bcd8 <_User_extensions_Iterate+0x30>  
4000bcf0:	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;                    
4000bcf4:	37 10 00 7d 	sethi  %hi(0x4001f400), %i3                    
4000bcf8:	fa 06 e2 84 	ld  [ %i3 + 0x284 ], %i5	! 4001f684 <_User_extensions_List>
4000bcfc:	b6 16 e2 84 	or  %i3, 0x284, %i3                            
    ++callouts_current;                                               
  }                                                                   
                                                                      
  node = _Chain_Immutable_first( &_User_extensions_List );            
  tail = _Chain_Immutable_tail( &_User_extensions_List );             
  while ( node != tail ) {                                            
4000bd00:	b6 06 e0 04 	add  %i3, 4, %i3                               
4000bd04:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000bd08:	02 80 00 09 	be  4000bd2c <_User_extensions_Iterate+0x84>   
4000bd0c:	94 07 60 14 	add  %i5, 0x14, %o2                            
    const User_extensions_Control *extension =                        
      (const User_extensions_Control *) node;                         
                                                                      
    (*visitor)( executing, arg, &extension->Callouts );               
4000bd10:	90 10 00 1c 	mov  %i4, %o0                                  
4000bd14:	9f c6 40 00 	call  %i1                                      
4000bd18:	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;                                              
4000bd1c:	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 ) {                                            
4000bd20:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000bd24:	12 bf ff fb 	bne  4000bd10 <_User_extensions_Iterate+0x68>  
4000bd28:	94 07 60 14 	add  %i5, 0x14, %o2                            
4000bd2c:	81 c7 e0 08 	ret                                            
4000bd30:	81 e8 00 00 	restore                                        
                                                                      

4000d77c <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) {
4000d77c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level level;                                                    
                                                                      
  _ISR_Disable( level );                                              
4000d780:	7f ff d6 a2 	call  40003208 <sparc_disable_interrupts>      
4000d784:	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;                    
4000d788:	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 );                            
4000d78c:	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 ) ) {                                 
4000d790:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000d794:	02 80 00 1f 	be  4000d810 <_Watchdog_Adjust+0x94>           
4000d798:	80 a6 60 00 	cmp  %i1, 0                                    
    switch ( direction ) {                                            
4000d79c:	12 80 00 1f 	bne  4000d818 <_Watchdog_Adjust+0x9c>          
4000d7a0:	80 a6 60 01 	cmp  %i1, 1                                    
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
        break;                                                        
      case WATCHDOG_FORWARD:                                          
        while ( units ) {                                             
4000d7a4:	80 a6 a0 00 	cmp  %i2, 0                                    
4000d7a8:	02 80 00 1a 	be  4000d810 <_Watchdog_Adjust+0x94>           <== NEVER TAKEN
4000d7ac:	01 00 00 00 	nop                                            
          if ( units < _Watchdog_First( header )->delta_interval ) {  
4000d7b0:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4000d7b4:	80 a6 80 02 	cmp  %i2, %g2                                  
4000d7b8:	1a 80 00 0a 	bcc  4000d7e0 <_Watchdog_Adjust+0x64>          <== ALWAYS TAKEN
4000d7bc:	b6 10 20 01 	mov  1, %i3                                    
            _Watchdog_First( header )->delta_interval -= units;       
4000d7c0:	10 80 00 1d 	b  4000d834 <_Watchdog_Adjust+0xb8>            <== NOT EXECUTED
4000d7c4:	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 ) {                                             
4000d7c8:	02 80 00 12 	be  4000d810 <_Watchdog_Adjust+0x94>           <== NEVER TAKEN
4000d7cc:	01 00 00 00 	nop                                            
          if ( units < _Watchdog_First( header )->delta_interval ) {  
4000d7d0:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4000d7d4:	80 a0 80 1a 	cmp  %g2, %i2                                  
4000d7d8:	38 80 00 17 	bgu,a   4000d834 <_Watchdog_Adjust+0xb8>       
4000d7dc:	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;            
4000d7e0:	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;       
4000d7e4:	b4 26 80 02 	sub  %i2, %g2, %i2                             
            _Watchdog_First( header )->delta_interval = 1;            
                                                                      
            _ISR_Enable( level );                                     
4000d7e8:	7f ff d6 8c 	call  40003218 <sparc_enable_interrupts>       
4000d7ec:	01 00 00 00 	nop                                            
                                                                      
            _Watchdog_Tickle( header );                               
4000d7f0:	40 00 00 a8 	call  4000da90 <_Watchdog_Tickle>              
4000d7f4:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
            _ISR_Disable( level );                                    
4000d7f8:	7f ff d6 84 	call  40003208 <sparc_disable_interrupts>      
4000d7fc:	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;                    
4000d800:	c2 06 00 00 	ld  [ %i0 ], %g1                               
                                                                      
            if ( _Chain_Is_empty( header ) )                          
4000d804:	80 a7 00 01 	cmp  %i4, %g1                                  
4000d808:	12 bf ff f0 	bne  4000d7c8 <_Watchdog_Adjust+0x4c>          
4000d80c:	80 a6 a0 00 	cmp  %i2, 0                                    
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4000d810:	7f ff d6 82 	call  40003218 <sparc_enable_interrupts>       
4000d814:	91 e8 00 08 	restore  %g0, %o0, %o0                         
   *       unmodified across that call.                               
   *                                                                  
   *       Till Straumann, 7/2003                                     
   */                                                                 
  if ( !_Chain_Is_empty( header ) ) {                                 
    switch ( direction ) {                                            
4000d818:	12 bf ff fe 	bne  4000d810 <_Watchdog_Adjust+0x94>          <== NEVER TAKEN
4000d81c:	01 00 00 00 	nop                                            
      case WATCHDOG_BACKWARD:                                         
        _Watchdog_First( header )->delta_interval += units;           
4000d820:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4000d824:	b4 00 80 1a 	add  %g2, %i2, %i2                             
4000d828:	f4 20 60 10 	st  %i2, [ %g1 + 0x10 ]                        
        }                                                             
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4000d82c:	7f ff d6 7b 	call  40003218 <sparc_enable_interrupts>       
4000d830:	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;                                                    
4000d834:	10 bf ff f7 	b  4000d810 <_Watchdog_Adjust+0x94>            
4000d838:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      

4001d438 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) {
4001d438:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Watchdog_Interval  units = units_arg;                               
  ISR_Level          level;                                           
  Watchdog_Control  *first;                                           
                                                                      
  _ISR_Disable( level );                                              
4001d43c:	7f ff c8 60 	call  4000f5bc <sparc_disable_interrupts>      
4001d440:	01 00 00 00 	nop                                            
4001d444:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4001d448:	ba 06 20 04 	add  %i0, 4, %i5                               
4001d44c:	b8 06 a0 04 	add  %i2, 4, %i4                               
                                                                      
  while ( 1 ) {                                                       
    if ( _Chain_Is_empty( header ) ) {                                
4001d450:	80 a7 40 01 	cmp  %i5, %g1                                  
4001d454:	02 80 00 20 	be  4001d4d4 <_Watchdog_Adjust_to_chain+0x9c>  
4001d458:	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 ) {                            
4001d45c:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4001d460:	80 a6 40 02 	cmp  %i1, %g2                                  
4001d464:	2a 80 00 1e 	bcs,a   4001d4dc <_Watchdog_Adjust_to_chain+0xa4>
4001d468:	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;                                   
4001d46c:	b2 26 40 02 	sub  %i1, %g2, %i1                             
    first->delta_interval = 0;                                        
4001d470:	c0 20 60 10 	clr  [ %g1 + 0x10 ]                            
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
4001d474:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4001d478:	c6 00 40 00 	ld  [ %g1 ], %g3                               
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4001d47c:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
4001d480:	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;                              
4001d484:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
                                                                      
  the_node->next = tail;                                              
4001d488:	f8 20 40 00 	st  %i4, [ %g1 ]                               
  tail->previous = the_node;                                          
4001d48c:	c2 26 a0 08 	st  %g1, [ %i2 + 8 ]                           
  old_last->next = the_node;                                          
4001d490:	c2 20 80 00 	st  %g1, [ %g2 ]                               
  the_node->previous = old_last;                                      
4001d494:	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 );                                            
4001d498:	7f ff c8 4d 	call  4000f5cc <sparc_enable_interrupts>       
4001d49c:	01 00 00 00 	nop                                            
4001d4a0:	7f ff c8 47 	call  4000f5bc <sparc_disable_interrupts>      
4001d4a4:	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;                    
4001d4a8:	c2 06 00 00 	ld  [ %i0 ], %g1                               
                                                                      
      if ( _Chain_Is_empty( header ) )                                
4001d4ac:	80 a7 40 01 	cmp  %i5, %g1                                  
4001d4b0:	02 bf ff e9 	be  4001d454 <_Watchdog_Adjust_to_chain+0x1c>  
4001d4b4:	01 00 00 00 	nop                                            
        break;                                                        
      first = _Watchdog_First( header );                              
      if ( first->delta_interval != 0 )                               
4001d4b8:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4001d4bc:	80 a0 a0 00 	cmp  %g2, 0                                    
4001d4c0:	22 bf ff ee 	be,a   4001d478 <_Watchdog_Adjust_to_chain+0x40>
4001d4c4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
  Watchdog_Control  *first;                                           
                                                                      
  _ISR_Disable( level );                                              
                                                                      
  while ( 1 ) {                                                       
    if ( _Chain_Is_empty( header ) ) {                                
4001d4c8:	80 a7 40 01 	cmp  %i5, %g1                                  
4001d4cc:	12 bf ff e6 	bne  4001d464 <_Watchdog_Adjust_to_chain+0x2c> <== ALWAYS TAKEN
4001d4d0:	80 a6 40 02 	cmp  %i1, %g2                                  
      if ( first->delta_interval != 0 )                               
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4001d4d4:	7f ff c8 3e 	call  4000f5cc <sparc_enable_interrupts>       
4001d4d8:	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;                                 
4001d4dc:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
      if ( first->delta_interval != 0 )                               
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  _ISR_Enable( level );                                               
4001d4e0:	7f ff c8 3b 	call  4000f5cc <sparc_enable_interrupts>       
4001d4e4:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

4000bf34 <_Watchdog_Remove>: #include <rtems/score/watchdog.h> Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) {
4000bf34:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level         level;                                            
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
4000bf38:	7f ff d9 66 	call  400024d0 <sparc_disable_interrupts>      
4000bf3c:	01 00 00 00 	nop                                            
  previous_state = the_watchdog->state;                               
4000bf40:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
  switch ( previous_state ) {                                         
4000bf44:	80 a7 60 01 	cmp  %i5, 1                                    
4000bf48:	02 80 00 2a 	be  4000bff0 <_Watchdog_Remove+0xbc>           
4000bf4c:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000bf50:	1a 80 00 09 	bcc  4000bf74 <_Watchdog_Remove+0x40>          
4000bf54:	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;               
4000bf58:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000bf5c:	c2 00 63 98 	ld  [ %g1 + 0x398 ], %g1	! 40020398 <_Watchdog_Ticks_since_boot>
4000bf60:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
4000bf64:	7f ff d9 5f 	call  400024e0 <sparc_enable_interrupts>       
4000bf68:	b0 10 00 1d 	mov  %i5, %i0                                  
  return( previous_state );                                           
}                                                                     
4000bf6c:	81 c7 e0 08 	ret                                            
4000bf70:	81 e8 00 00 	restore                                        
  Watchdog_States   previous_state;                                   
  Watchdog_Control *next_watchdog;                                    
                                                                      
  _ISR_Disable( level );                                              
  previous_state = the_watchdog->state;                               
  switch ( previous_state ) {                                         
4000bf74:	18 bf ff fa 	bgu  4000bf5c <_Watchdog_Remove+0x28>          <== NEVER TAKEN
4000bf78:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(                
  Watchdog_Control *the_watchdog                                      
)                                                                     
{                                                                     
                                                                      
  return ( (Watchdog_Control *) the_watchdog->Node.next );            
4000bf7c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      break;                                                          
                                                                      
    case WATCHDOG_ACTIVE:                                             
    case WATCHDOG_REMOVE_IT:                                          
                                                                      
      the_watchdog->state = WATCHDOG_INACTIVE;                        
4000bf80:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
      next_watchdog = _Watchdog_Next( the_watchdog );                 
                                                                      
      if ( _Watchdog_Next(next_watchdog) )                            
4000bf84:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000bf88:	80 a0 a0 00 	cmp  %g2, 0                                    
4000bf8c:	02 80 00 07 	be  4000bfa8 <_Watchdog_Remove+0x74>           
4000bf90:	05 10 00 80 	sethi  %hi(0x40020000), %g2                    
        next_watchdog->delta_interval += the_watchdog->delta_interval;
4000bf94:	c6 00 60 10 	ld  [ %g1 + 0x10 ], %g3                        
4000bf98:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4000bf9c:	84 00 c0 02 	add  %g3, %g2, %g2                             
4000bfa0:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
      if ( _Watchdog_Sync_count )                                     
4000bfa4:	05 10 00 80 	sethi  %hi(0x40020000), %g2                    
4000bfa8:	c4 00 a3 94 	ld  [ %g2 + 0x394 ], %g2	! 40020394 <_Watchdog_Sync_count>
4000bfac:	80 a0 a0 00 	cmp  %g2, 0                                    
4000bfb0:	22 80 00 07 	be,a   4000bfcc <_Watchdog_Remove+0x98>        
4000bfb4:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
        _Watchdog_Sync_level = _ISR_Nest_level;                       
4000bfb8:	05 10 00 81 	sethi  %hi(0x40020400), %g2                    
4000bfbc:	c6 00 a3 c8 	ld  [ %g2 + 0x3c8 ], %g3	! 400207c8 <_Per_CPU_Information+0x8>
4000bfc0:	05 10 00 80 	sethi  %hi(0x40020000), %g2                    
4000bfc4:	c6 20 a3 34 	st  %g3, [ %g2 + 0x334 ]	! 40020334 <_Watchdog_Sync_level>
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
4000bfc8:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
  next->previous = previous;                                          
4000bfcc:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  previous->next = next;                                              
4000bfd0:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
      _Chain_Extract_unprotected( &the_watchdog->Node );              
      break;                                                          
  }                                                                   
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;               
4000bfd4:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000bfd8:	c2 00 63 98 	ld  [ %g1 + 0x398 ], %g1	! 40020398 <_Watchdog_Ticks_since_boot>
4000bfdc:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
4000bfe0:	7f ff d9 40 	call  400024e0 <sparc_enable_interrupts>       
4000bfe4:	b0 10 00 1d 	mov  %i5, %i0                                  
  return( previous_state );                                           
}                                                                     
4000bfe8:	81 c7 e0 08 	ret                                            
4000bfec:	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;               
4000bff0:	c2 00 63 98 	ld  [ %g1 + 0x398 ], %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;                        
4000bff4:	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;               
4000bff8:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
                                                                      
  _ISR_Enable( level );                                               
4000bffc:	7f ff d9 39 	call  400024e0 <sparc_enable_interrupts>       
4000c000:	b0 10 00 1d 	mov  %i5, %i0                                  
  return( previous_state );                                           
}                                                                     
4000c004:	81 c7 e0 08 	ret                                            
4000c008:	81 e8 00 00 	restore                                        
                                                                      

4000d1bc <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) {
4000d1bc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level          level;                                           
  Chain_Node        *node;                                            
                                                                      
  _ISR_Disable( level );                                              
4000d1c0:	7f ff d7 10 	call  40002e00 <sparc_disable_interrupts>      
4000d1c4:	01 00 00 00 	nop                                            
4000d1c8:	b6 10 00 08 	mov  %o0, %i3                                  
    printk( "Watchdog Chain: %s %p\n", name, header );                
4000d1cc:	11 10 00 80 	sethi  %hi(0x40020000), %o0                    
4000d1d0:	94 10 00 19 	mov  %i1, %o2                                  
4000d1d4:	92 10 00 18 	mov  %i0, %o1                                  
4000d1d8:	7f ff e1 fa 	call  400059c0 <printk>                        
4000d1dc:	90 12 22 38 	or  %o0, 0x238, %o0                            
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000d1e0:	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 );                            
4000d1e4:	b2 06 60 04 	add  %i1, 4, %i1                               
    if ( !_Chain_Is_empty( header ) ) {                               
4000d1e8:	80 a7 40 19 	cmp  %i5, %i1                                  
4000d1ec:	02 80 00 0f 	be  4000d228 <_Watchdog_Report_chain+0x6c>     
4000d1f0:	11 10 00 80 	sethi  %hi(0x40020000), %o0                    
            node != _Chain_Tail(header) ;                             
            node = node->next )                                       
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
4000d1f4:	92 10 00 1d 	mov  %i5, %o1                                  
4000d1f8:	40 00 00 0f 	call  4000d234 <_Watchdog_Report>              
4000d1fc:	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 )                                       
4000d200:	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 ) ;                           
4000d204:	80 a7 40 19 	cmp  %i5, %i1                                  
4000d208:	12 bf ff fc 	bne  4000d1f8 <_Watchdog_Report_chain+0x3c>    <== NEVER TAKEN
4000d20c:	92 10 00 1d 	mov  %i5, %o1                                  
      {                                                               
        Watchdog_Control *watch = (Watchdog_Control *) node;          
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
4000d210:	11 10 00 80 	sethi  %hi(0x40020000), %o0                    
4000d214:	92 10 00 18 	mov  %i0, %o1                                  
4000d218:	7f ff e1 ea 	call  400059c0 <printk>                        
4000d21c:	90 12 22 50 	or  %o0, 0x250, %o0                            
    } else {                                                          
      printk( "Chain is empty\n" );                                   
    }                                                                 
  _ISR_Enable( level );                                               
4000d220:	7f ff d6 fc 	call  40002e10 <sparc_enable_interrupts>       
4000d224:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
                                                                      
        _Watchdog_Report( NULL, watch );                              
      }                                                               
      printk( "== end of %s \n", name );                              
    } else {                                                          
      printk( "Chain is empty\n" );                                   
4000d228:	7f ff e1 e6 	call  400059c0 <printk>                        
4000d22c:	90 12 22 60 	or  %o0, 0x260, %o0                            
4000d230:	30 bf ff fc 	b,a   4000d220 <_Watchdog_Report_chain+0x64>   
                                                                      

4000c00c <_Watchdog_Tickle>: #include <rtems/score/watchdog.h> void _Watchdog_Tickle( Chain_Control *header ) {
4000c00c:	9d e3 bf a0 	save  %sp, -96, %sp                            
   * See the comment in watchdoginsert.c and watchdogadjust.c         
   * about why it's safe not to declare header a pointer to           
   * volatile data - till, 2003/7                                     
   */                                                                 
                                                                      
  _ISR_Disable( level );                                              
4000c010:	7f ff d9 30 	call  400024d0 <sparc_disable_interrupts>      
4000c014:	01 00 00 00 	nop                                            
4000c018:	b8 10 00 08 	mov  %o0, %i4                                  
 */                                                                   
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(        
  const Chain_Control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Immutable_head( the_chain )->next;                    
4000c01c:	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 );                            
4000c020:	b4 06 20 04 	add  %i0, 4, %i2                               
                                                                      
  if ( _Chain_Is_empty( header ) )                                    
4000c024:	80 a7 40 1a 	cmp  %i5, %i2                                  
4000c028:	02 80 00 09 	be  4000c04c <_Watchdog_Tickle+0x40>           
4000c02c:	01 00 00 00 	nop                                            
   * to be inserted has already had its delta_interval adjusted to 0, and
   * so is added to the head of the chain with a delta_interval of 0. 
   *                                                                  
   * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)              
   */                                                                 
  if (the_watchdog->delta_interval != 0) {                            
4000c030:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000c034:	80 a0 60 00 	cmp  %g1, 0                                    
4000c038:	02 80 00 15 	be  4000c08c <_Watchdog_Tickle+0x80>           <== NEVER TAKEN
4000c03c:	82 00 7f ff 	add  %g1, -1, %g1                              
    the_watchdog->delta_interval--;                                   
    if ( the_watchdog->delta_interval != 0 )                          
4000c040:	80 a0 60 00 	cmp  %g1, 0                                    
4000c044:	02 80 00 12 	be  4000c08c <_Watchdog_Tickle+0x80>           
4000c048:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
     the_watchdog = _Watchdog_First( header );                        
   } while ( !_Chain_Is_empty( header ) &&                            
             (the_watchdog->delta_interval == 0) );                   
                                                                      
leave:                                                                
   _ISR_Enable(level);                                                
4000c04c:	7f ff d9 25 	call  400024e0 <sparc_enable_interrupts>       
4000c050:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
                                                                      
     _ISR_Enable( level );                                            
                                                                      
     switch( watchdog_state ) {                                       
       case WATCHDOG_ACTIVE:                                          
         (*the_watchdog->routine)(                                    
4000c054:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
4000c058:	9f c0 40 00 	call  %g1                                      
4000c05c:	d2 07 60 24 	ld  [ %i5 + 0x24 ], %o1                        
                                                                      
       case WATCHDOG_REMOVE_IT:                                       
         break;                                                       
     }                                                                
                                                                      
     _ISR_Disable( level );                                           
4000c060:	7f ff d9 1c 	call  400024d0 <sparc_disable_interrupts>      
4000c064:	01 00 00 00 	nop                                            
4000c068:	b8 10 00 08 	mov  %o0, %i4                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000c06c:	fa 06 00 00 	ld  [ %i0 ], %i5                               
                                                                      
     the_watchdog = _Watchdog_First( header );                        
   } while ( !_Chain_Is_empty( header ) &&                            
             (the_watchdog->delta_interval == 0) );                   
4000c070:	80 a6 80 1d 	cmp  %i2, %i5                                  
4000c074:	02 bf ff f6 	be  4000c04c <_Watchdog_Tickle+0x40>           
4000c078:	01 00 00 00 	nop                                            
     }                                                                
                                                                      
     _ISR_Disable( level );                                           
                                                                      
     the_watchdog = _Watchdog_First( header );                        
   } while ( !_Chain_Is_empty( header ) &&                            
4000c07c:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000c080:	80 a0 60 00 	cmp  %g1, 0                                    
4000c084:	12 bf ff f2 	bne  4000c04c <_Watchdog_Tickle+0x40>          
4000c088:	01 00 00 00 	nop                                            
    if ( the_watchdog->delta_interval != 0 )                          
      goto leave;                                                     
  }                                                                   
                                                                      
  do {                                                                
     watchdog_state = _Watchdog_Remove( the_watchdog );               
4000c08c:	7f ff ff aa 	call  4000bf34 <_Watchdog_Remove>              
4000c090:	90 10 00 1d 	mov  %i5, %o0                                  
4000c094:	b6 10 00 08 	mov  %o0, %i3                                  
                                                                      
     _ISR_Enable( level );                                            
4000c098:	7f ff d9 12 	call  400024e0 <sparc_enable_interrupts>       
4000c09c:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
     switch( watchdog_state ) {                                       
4000c0a0:	80 a6 e0 02 	cmp  %i3, 2                                    
4000c0a4:	12 bf ff ef 	bne  4000c060 <_Watchdog_Tickle+0x54>          
4000c0a8:	01 00 00 00 	nop                                            
       case WATCHDOG_ACTIVE:                                          
         (*the_watchdog->routine)(                                    
4000c0ac:	10 bf ff ea 	b  4000c054 <_Watchdog_Tickle+0x48>            
4000c0b0:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %o0                        
                                                                      

4000c0b4 <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( Heap_Area *areas, size_t area_count, Heap_Initialization_or_extend_handler extend ) {
4000c0b4:	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();    
4000c0b8:	05 10 00 75 	sethi  %hi(0x4001d400), %g2                    
4000c0bc:	82 10 a2 18 	or  %g2, 0x218, %g1	! 4001d618 <Configuration> 
4000c0c0:	c6 08 60 32 	ldub  [ %g1 + 0x32 ], %g3                      
4000c0c4:	f6 00 a2 18 	ld  [ %g2 + 0x218 ], %i3                       
4000c0c8:	80 a0 e0 00 	cmp  %g3, 0                                    
4000c0cc:	12 80 00 03 	bne  4000c0d8 <_Workspace_Handler_initialization+0x24>
4000c0d0:	84 10 20 00 	clr  %g2                                       
4000c0d4:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000c0d8:	b6 00 80 1b 	add  %g2, %i3, %i3                             
  bool do_zero = rtems_configuration_get_do_zero_of_workspace();      
4000c0dc:	c4 08 60 30 	ldub  [ %g1 + 0x30 ], %g2                      
  bool unified = rtems_configuration_get_unified_work_area();         
4000c0e0:	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();      
4000c0e4:	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) {                                  
4000c0e8:	80 a6 60 00 	cmp  %i1, 0                                    
4000c0ec:	02 80 00 3c 	be  4000c1dc <_Workspace_Handler_initialization+0x128><== NEVER TAKEN
4000c0f0:	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;
4000c0f4:	23 10 00 26 	sethi  %hi(0x40009800), %l1                    
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
4000c0f8:	27 10 00 80 	sethi  %hi(0x40020000), %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) {                                  
4000c0fc:	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;
4000c100:	a2 14 60 98 	or  %l1, 0x98, %l1                             
4000c104:	a0 08 a0 ff 	and  %g2, 0xff, %l0                            
                                                                      
    if ( area->size > overhead ) {                                    
      uintptr_t space_available;                                      
      uintptr_t size;                                                 
                                                                      
      if ( unified ) {                                                
4000c108:	a4 08 60 ff 	and  %g1, 0xff, %l2                            
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
4000c10c:	10 80 00 22 	b  4000c194 <_Workspace_Handler_initialization+0xe0>
4000c110:	a6 14 e2 c0 	or  %l3, 0x2c0, %l3                            
                                                                      
    if ( do_zero ) {                                                  
      memset( area->begin, 0, area->size );                           
    }                                                                 
                                                                      
    if ( area->size > overhead ) {                                    
4000c114:	80 a7 60 16 	cmp  %i5, 0x16                                 
4000c118:	28 80 00 1c 	bleu,a   4000c188 <_Workspace_Handler_initialization+0xd4>
4000c11c:	b8 07 20 01 	inc  %i4                                       
      uintptr_t space_available;                                      
      uintptr_t size;                                                 
                                                                      
      if ( unified ) {                                                
4000c120:	80 a4 a0 00 	cmp  %l2, 0                                    
4000c124:	32 80 00 0a 	bne,a   4000c14c <_Workspace_Handler_initialization+0x98>
4000c128:	d2 06 00 00 	ld  [ %i0 ], %o1                               
        size = area->size;                                            
      } else {                                                        
        if ( remaining > 0 ) {                                        
4000c12c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000c130:	22 80 00 22 	be,a   4000c1b8 <_Workspace_Handler_initialization+0x104><== NEVER TAKEN
4000c134:	d2 06 00 00 	ld  [ %i0 ], %o1                               <== NOT EXECUTED
          size = remaining < area->size - overhead ?                  
4000c138:	82 07 7f ea 	add  %i5, -22, %g1                             
            remaining + overhead : area->size;                        
4000c13c:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000c140:	38 80 00 02 	bgu,a   4000c148 <_Workspace_Handler_initialization+0x94><== ALWAYS TAKEN
4000c144:	ba 06 e0 16 	add  %i3, 0x16, %i5                            
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
4000c148:	d2 06 00 00 	ld  [ %i0 ], %o1                               
4000c14c:	94 10 00 1d 	mov  %i5, %o2                                  
4000c150:	90 10 00 13 	mov  %l3, %o0                                  
4000c154:	9f c4 40 00 	call  %l1                                      
4000c158:	96 10 20 08 	mov  8, %o3                                    
        area->begin,                                                  
        size,                                                         
        page_size                                                     
      );                                                              
                                                                      
      area->begin = (char *) area->begin + size;                      
4000c15c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      area->size -= size;                                             
4000c160:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
        area->begin,                                                  
        size,                                                         
        page_size                                                     
      );                                                              
                                                                      
      area->begin = (char *) area->begin + size;                      
4000c164:	82 00 40 1d 	add  %g1, %i5, %g1                             
      area->size -= size;                                             
4000c168:	ba 20 80 1d 	sub  %g2, %i5, %i5                             
        area->begin,                                                  
        size,                                                         
        page_size                                                     
      );                                                              
                                                                      
      area->begin = (char *) area->begin + size;                      
4000c16c:	c2 26 00 00 	st  %g1, [ %i0 ]                               
      area->size -= size;                                             
                                                                      
      if ( space_available < remaining ) {                            
4000c170:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000c174:	1a 80 00 1f 	bcc  4000c1f0 <_Workspace_Handler_initialization+0x13c><== ALWAYS TAKEN
4000c178:	fa 26 20 04 	st  %i5, [ %i0 + 4 ]                           
        remaining -= space_available;                                 
4000c17c:	b6 26 c0 08 	sub  %i3, %o0, %i3                             <== NOT EXECUTED
      } else {                                                        
        remaining = 0;                                                
      }                                                               
                                                                      
      init_or_extend = extend;                                        
4000c180:	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) {                                  
4000c184:	b8 07 20 01 	inc  %i4                                       
4000c188:	80 a7 00 19 	cmp  %i4, %i1                                  
4000c18c:	02 80 00 14 	be  4000c1dc <_Workspace_Handler_initialization+0x128><== ALWAYS TAKEN
4000c190:	b0 06 20 08 	add  %i0, 8, %i0                               
    Heap_Area *area = &areas [i];                                     
                                                                      
    if ( do_zero ) {                                                  
4000c194:	80 a4 20 00 	cmp  %l0, 0                                    
4000c198:	22 bf ff df 	be,a   4000c114 <_Workspace_Handler_initialization+0x60>
4000c19c:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
      memset( area->begin, 0, area->size );                           
4000c1a0:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000c1a4:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
4000c1a8:	40 00 14 74 	call  40011378 <memset>                        
4000c1ac:	92 10 20 00 	clr  %o1                                       
    }                                                                 
                                                                      
    if ( area->size > overhead ) {                                    
4000c1b0:	10 bf ff d9 	b  4000c114 <_Workspace_Handler_initialization+0x60>
4000c1b4:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
        } else {                                                      
          size = 0;                                                   
        }                                                             
      }                                                               
                                                                      
      space_available = (*init_or_extend)(                            
4000c1b8:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
4000c1bc:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000c1c0:	9f c4 40 00 	call  %l1                                      <== NOT EXECUTED
4000c1c4:	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) {                                  
4000c1c8:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
        remaining -= space_available;                                 
      } else {                                                        
        remaining = 0;                                                
      }                                                               
                                                                      
      init_or_extend = extend;                                        
4000c1cc:	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) {                                  
4000c1d0:	80 a7 00 19 	cmp  %i4, %i1                                  <== NOT EXECUTED
4000c1d4:	12 bf ff f0 	bne  4000c194 <_Workspace_Handler_initialization+0xe0><== NOT EXECUTED
4000c1d8:	b0 06 20 08 	add  %i0, 8, %i0                               <== NOT EXECUTED
                                                                      
      init_or_extend = extend;                                        
    }                                                                 
  }                                                                   
                                                                      
  if ( remaining > 0 ) {                                              
4000c1dc:	80 a6 e0 00 	cmp  %i3, 0                                    
4000c1e0:	12 80 00 07 	bne  4000c1fc <_Workspace_Handler_initialization+0x148>
4000c1e4:	90 10 20 00 	clr  %o0                                       
4000c1e8:	81 c7 e0 08 	ret                                            
4000c1ec:	81 e8 00 00 	restore                                        
        remaining -= space_available;                                 
      } else {                                                        
        remaining = 0;                                                
      }                                                               
                                                                      
      init_or_extend = extend;                                        
4000c1f0:	a2 10 00 1a 	mov  %i2, %l1                                  
      area->size -= size;                                             
                                                                      
      if ( space_available < remaining ) {                            
        remaining -= space_available;                                 
      } else {                                                        
        remaining = 0;                                                
4000c1f4:	10 bf ff e4 	b  4000c184 <_Workspace_Handler_initialization+0xd0>
4000c1f8:	b6 10 20 00 	clr  %i3                                       
      init_or_extend = extend;                                        
    }                                                                 
  }                                                                   
                                                                      
  if ( remaining > 0 ) {                                              
    _Internal_error_Occurred(                                         
4000c1fc:	92 10 20 01 	mov  1, %o1                                    
4000c200:	7f ff f6 43 	call  40009b0c <_Internal_error_Occurred>      
4000c204:	94 10 20 02 	mov  2, %o2                                    
                                                                      

4001c6a0 <_calloc_r>: struct _reent *ignored __attribute__((unused)), size_t elements, size_t size ) { return calloc( elements, size );
4001c6a0:	90 10 00 09 	mov  %o1, %o0                                  <== NOT EXECUTED
4001c6a4:	92 10 00 0a 	mov  %o2, %o1                                  <== NOT EXECUTED
4001c6a8:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
4001c6ac:	7f ff 9e 28 	call  40003f4c <calloc>                        <== NOT EXECUTED
4001c6b0:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

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

400146d8 <_fat_block_read>: uint32_t start, uint32_t offset, uint32_t count, void *buff ) {
400146d8:	9d e3 bf 98 	save  %sp, -104, %sp                           
400146dc:	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)                                                 
400146e0:	80 a6 e0 00 	cmp  %i3, 0                                    
400146e4:	12 80 00 11 	bne  40014728 <_fat_block_read+0x50>           <== ALWAYS TAKEN
400146e8:	b0 10 20 00 	clr  %i0                                       
400146ec:	30 80 00 19 	b,a   40014750 <_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));                     
400146f0:	fa 14 00 00 	lduh  [ %l0 ], %i5                             
        memcpy((buff + cmpltd), (sec_buf + ofs), c);                  
400146f4:	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));                     
400146f8:	ba 27 40 1a 	sub  %i5, %i2, %i5                             
400146fc:	80 a7 40 1b 	cmp  %i5, %i3                                  
40014700:	08 80 00 03 	bleu  4001470c <_fat_block_read+0x34>          
40014704:	92 02 40 1a 	add  %o1, %i2, %o1                             
40014708:	ba 10 00 1b 	mov  %i3, %i5                                  
        memcpy((buff + cmpltd), (sec_buf + ofs), c);                  
4001470c:	40 00 26 46 	call  4001e024 <memcpy>                        
40014710:	94 10 00 1d 	mov  %i5, %o2                                  
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
40014714:	b0 07 40 18 	add  %i5, %i0, %i0                             
        sec_num++;                                                    
40014718:	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)                                                 
4001471c:	b6 a6 c0 1d 	subcc  %i3, %i5, %i3                           
40014720:	02 80 00 0c 	be  40014750 <_fat_block_read+0x78>            
40014724:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
        rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_READ, &sec_buf);
40014728:	92 10 00 19 	mov  %i1, %o1                                  
4001472c:	94 10 20 01 	mov  1, %o2                                    
40014730:	96 07 bf fc 	add  %fp, -4, %o3                              
40014734:	7f ff ff bb 	call  40014620 <fat_buf_access>                
40014738:	90 10 00 10 	mov  %l0, %o0                                  
        if (rc != RC_OK)                                              
4001473c:	80 a2 20 00 	cmp  %o0, 0                                    
40014740:	02 bf ff ec 	be  400146f0 <_fat_block_read+0x18>            <== ALWAYS TAKEN
40014744:	90 07 00 18 	add  %i4, %i0, %o0                             
        cmpltd += c;                                                  
        sec_num++;                                                    
        ofs = 0;                                                      
    }                                                                 
    return cmpltd;                                                    
}                                                                     
40014748:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001474c:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
40014750:	81 c7 e0 08 	ret                                            
40014754:	81 e8 00 00 	restore                                        
                                                                      

40004d24 <_lstat_r>: struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf );
40004d24:	90 10 00 09 	mov  %o1, %o0                                  <== NOT EXECUTED
40004d28:	92 10 00 0a 	mov  %o2, %o1                                  <== NOT EXECUTED
40004d2c:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
40004d30:	7f ff ff e9 	call  40004cd4 <lstat>                         <== NOT EXECUTED
40004d34:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

40005118 <_stat_r>: struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf );
40005118:	90 10 00 09 	mov  %o1, %o0                                  <== NOT EXECUTED
4000511c:	92 10 00 0a 	mov  %o2, %o1                                  <== NOT EXECUTED
40005120:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
40005124:	7f ff ff e9 	call  400050c8 <stat>                          <== NOT EXECUTED
40005128:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

400080c0 <adjtime>: */ int adjtime( const struct timeval *delta, struct timeval *olddelta ) {
400080c0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long   adjustment;                                                  
                                                                      
  /*                                                                  
   * Simple validations                                               
   */                                                                 
  if ( !delta )                                                       
400080c4:	80 a6 20 00 	cmp  %i0, 0                                    
400080c8:	02 80 00 8e 	be  40008300 <adjtime+0x240>                   
400080cc:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )                
400080d0:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
400080d4:	03 00 03 d0 	sethi  %hi(0xf4000), %g1                       
400080d8:	82 10 62 3f 	or  %g1, 0x23f, %g1	! f423f <PROM_START+0xf423f>
400080dc:	80 a0 80 01 	cmp  %g2, %g1                                  
400080e0:	18 80 00 88 	bgu  40008300 <adjtime+0x240>                  
400080e4:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( olddelta ) {                                                   
400080e8:	22 80 00 06 	be,a   40008100 <adjtime+0x40>                 
400080ec:	c2 06 00 00 	ld  [ %i0 ], %g1                               
    olddelta->tv_sec  = 0;                                            
    olddelta->tv_usec = 0;                                            
400080f0:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
400080f4:	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;                                            
400080f8:	c0 26 40 00 	clr  [ %i1 ]                                   
    olddelta->tv_usec = 0;                                            
  }                                                                   
                                                                      
  /* convert delta to microseconds */                                 
  adjustment  = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);        
400080fc:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  adjustment += delta->tv_usec;                                       
                                                                      
  /* too small to account for */                                      
  if ( adjustment < rtems_configuration_get_microseconds_per_tick() ) 
40008100:	07 10 00 61 	sethi  %hi(0x40018400), %g3                    
40008104:	c8 00 e3 4c 	ld  [ %g3 + 0x34c ], %g4	! 4001874c <Configuration+0xc>
    olddelta->tv_sec  = 0;                                            
    olddelta->tv_usec = 0;                                            
  }                                                                   
                                                                      
  /* convert delta to microseconds */                                 
  adjustment  = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);        
40008108:	bb 28 60 08 	sll  %g1, 8, %i5                               
4000810c:	87 28 60 03 	sll  %g1, 3, %g3                               
40008110:	86 27 40 03 	sub  %i5, %g3, %g3                             
40008114:	bb 28 e0 06 	sll  %g3, 6, %i5                               
40008118:	86 27 40 03 	sub  %i5, %g3, %g3                             
4000811c:	82 00 c0 01 	add  %g3, %g1, %g1                             
40008120:	83 28 60 06 	sll  %g1, 6, %g1                               
  adjustment += delta->tv_usec;                                       
40008124:	84 00 40 02 	add  %g1, %g2, %g2                             
                                                                      
  /* too small to account for */                                      
  if ( adjustment < rtems_configuration_get_microseconds_per_tick() ) 
40008128:	80 a0 80 04 	cmp  %g2, %g4                                  
4000812c:	1a 80 00 05 	bcc  40008140 <adjtime+0x80>                   
40008130:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
    return 0;                                                         
40008134:	82 10 20 00 	clr  %g1                                       
  /* set the user's output */                                         
  if ( olddelta )                                                     
    *olddelta = *delta;                                               
                                                                      
  return 0;                                                           
}                                                                     
40008138:	81 c7 e0 08 	ret                                            
4000813c:	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;                  
40008140:	c4 00 63 e0 	ld  [ %g1 + 0x3e0 ], %g2                       
                                                                      
    ++level;                                                          
40008144:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40008148:	c4 20 63 e0 	st  %g2, [ %g1 + 0x3e0 ]                       
)                                                                     
{                                                                     
  Timestamp_Control  tod_as_timestamp;                                
  Timestamp_Control *tod_as_timestamp_ptr;                            
                                                                      
  tod_as_timestamp_ptr =                                              
4000814c:	13 10 00 6a 	sethi  %hi(0x4001a800), %o1                    
40008150:	90 07 bf f8 	add  %fp, -8, %o0                              
40008154:	40 00 07 1c 	call  40009dc4 <_TOD_Get_with_nanoseconds>     
40008158:	92 12 63 28 	or  %o1, 0x328, %o1                            
4000815c:	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);           
40008160:	94 10 20 00 	clr  %o2                                       
40008164:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40008168:	90 10 00 1c 	mov  %i4, %o0                                  
4000816c:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40008170:	40 00 3a 42 	call  40016a78 <__divdi3>                      
40008174:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
    _TOD_Get( &ts );                                                  
                                                                      
    ts.tv_sec  += delta->tv_sec;                                      
40008178:	f6 06 00 00 	ld  [ %i0 ], %i3                               
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
4000817c:	94 10 20 00 	clr  %o2                                       
40008180:	b6 06 c0 09 	add  %i3, %o1, %i3                             
40008184:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40008188:	90 10 00 1c 	mov  %i4, %o0                                  
4000818c:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40008190:	40 00 3b 25 	call  40016e24 <__moddi3>                      
40008194:	92 10 00 1d 	mov  %i5, %o1                                  
    ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;   
40008198:	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;                       
4000819c:	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;   
400081a0:	87 28 60 07 	sll  %g1, 7, %g3                               
400081a4:	85 28 60 02 	sll  %g1, 2, %g2                               
400081a8:	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;                       
400081ac:	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;   
400081b0:	82 00 80 01 	add  %g2, %g1, %g1                             
                                                                      
    /* if adjustment is too much positive */                          
    while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {              
400081b4:	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;   
400081b8:	83 28 60 03 	sll  %g1, 3, %g1                               
                                                                      
    /* if adjustment is too much positive */                          
    while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {              
400081bc:	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;   
400081c0:	92 02 40 01 	add  %o1, %g1, %o1                             
                                                                      
    /* if adjustment is too much positive */                          
    while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {              
400081c4:	80 a2 40 03 	cmp  %o1, %g3                                  
400081c8:	08 80 00 07 	bleu  400081e4 <adjtime+0x124>                 
400081cc:	84 06 e0 01 	add  %i3, 1, %g2                               
      ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;                       
400081d0:	92 02 40 04 	add  %o1, %g4, %o1                             
      ts.tv_sec++;                                                    
400081d4:	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 ) {              
400081d8:	80 a2 40 03 	cmp  %o1, %g3                                  
400081dc:	18 bf ff fd 	bgu  400081d0 <adjtime+0x110>                  <== NEVER TAKEN
400081e0:	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;                       
400081e4:	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) ) {       
400081e8:	07 31 19 4d 	sethi  %hi(0xc4653400), %g3                    
400081ec:	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 *));       
400081f0:	84 06 ff ff 	add  %i3, -1, %g2                              
      ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;                       
400081f4:	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) ) {       
400081f8:	86 10 e2 00 	or  %g3, 0x200, %g3                            
      ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;                       
400081fc:	82 00 40 1d 	add  %g1, %i5, %g1                             
      ts.tv_sec--;                                                    
40008200:	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) ) {       
40008204:	80 a0 40 03 	cmp  %g1, %g3                                  
40008208:	08 bf ff fd 	bleu  400081fc <adjtime+0x13c>                 
4000820c:	84 00 bf ff 	add  %g2, -1, %g2                              
  const struct timespec *tod_as_timespec                              
)                                                                     
{                                                                     
  Timestamp_Control tod_as_timestamp;                                 
                                                                      
  _Timestamp_Set(                                                     
40008210:	85 39 20 1f 	sra  %g4, 0x1f, %g2                            
40008214:	a6 10 00 01 	mov  %g1, %l3                                  
40008218:	a5 38 60 1f 	sra  %g1, 0x1f, %l2                            
  Timestamp64_Control *_time,                                         
  Timestamp64_Control  _seconds,                                      
  Timestamp64_Control  _nanoseconds                                   
)                                                                     
{                                                                     
  *_time = _seconds * 1000000000L + _nanoseconds;                     
4000821c:	83 28 a0 03 	sll  %g2, 3, %g1                               
40008220:	86 10 00 04 	mov  %g4, %g3                                  
40008224:	89 31 20 1d 	srl  %g4, 0x1d, %g4                            
40008228:	bb 28 e0 03 	sll  %g3, 3, %i5                               
4000822c:	b8 11 00 01 	or  %g4, %g1, %i4                              
40008230:	83 37 60 1b 	srl  %i5, 0x1b, %g1                            
40008234:	a9 2f 20 05 	sll  %i4, 5, %l4                               
40008238:	ab 2f 60 05 	sll  %i5, 5, %l5                               
4000823c:	a8 10 40 14 	or  %g1, %l4, %l4                              
40008240:	ba a5 40 1d 	subcc  %l5, %i5, %i5                           
40008244:	83 37 60 1a 	srl  %i5, 0x1a, %g1                            
40008248:	b8 65 00 1c 	subx  %l4, %i4, %i4                            
4000824c:	a3 2f 60 06 	sll  %i5, 6, %l1                               
40008250:	a1 2f 20 06 	sll  %i4, 6, %l0                               
40008254:	ba a4 40 1d 	subcc  %l1, %i5, %i5                           
40008258:	a0 10 40 10 	or  %g1, %l0, %l0                              
4000825c:	b8 64 00 1c 	subx  %l0, %i4, %i4                            
40008260:	ae 87 40 03 	addcc  %i5, %g3, %l7                           
40008264:	83 35 e0 1e 	srl  %l7, 0x1e, %g1                            
40008268:	ac 47 00 02 	addx  %i4, %g2, %l6                            
4000826c:	97 2d e0 02 	sll  %l7, 2, %o3                               
40008270:	95 2d a0 02 	sll  %l6, 2, %o2                               
40008274:	86 85 c0 0b 	addcc  %l7, %o3, %g3                           
40008278:	94 10 40 0a 	or  %g1, %o2, %o2                              
4000827c:	9b 28 e0 02 	sll  %g3, 2, %o5                               
40008280:	84 45 80 0a 	addx  %l6, %o2, %g2                            
40008284:	83 30 e0 1e 	srl  %g3, 0x1e, %g1                            
40008288:	ba 80 c0 0d 	addcc  %g3, %o5, %i5                           
4000828c:	99 28 a0 02 	sll  %g2, 2, %o4                               
40008290:	b7 2f 60 02 	sll  %i5, 2, %i3                               
40008294:	98 10 40 0c 	or  %g1, %o4, %o4                              
40008298:	83 37 60 1e 	srl  %i5, 0x1e, %g1                            
4000829c:	b8 40 80 0c 	addx  %g2, %o4, %i4                            
400082a0:	86 87 40 1b 	addcc  %i5, %i3, %g3                           
400082a4:	b5 2f 20 02 	sll  %i4, 2, %i2                               
400082a8:	bb 30 e0 17 	srl  %g3, 0x17, %i5                            
400082ac:	b4 10 40 1a 	or  %g1, %i2, %i2                              
400082b0:	84 47 00 1a 	addx  %i4, %i2, %g2                            
400082b4:	83 28 e0 09 	sll  %g3, 9, %g1                               
400082b8:	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 );                       
400082bc:	90 07 bf f8 	add  %fp, -8, %o0                              
400082c0:	84 17 40 04 	or  %i5, %g4, %g2                              
400082c4:	ba 84 c0 01 	addcc  %l3, %g1, %i5                           
400082c8:	b8 44 80 02 	addx  %l2, %g2, %i4                            
400082cc:	40 00 06 d9 	call  40009e30 <_TOD_Set_with_timestamp>       
400082d0:	f8 3f bf f8 	std  %i4, [ %fp + -8 ]                         
      ts.tv_sec--;                                                    
    }                                                                 
                                                                      
    _TOD_Set( &ts );                                                  
                                                                      
  _Thread_Enable_dispatch();                                          
400082d4:	40 00 0d 7e 	call  4000b8cc <_Thread_Enable_dispatch>       
400082d8:	01 00 00 00 	nop                                            
                                                                      
  /* set the user's output */                                         
  if ( olddelta )                                                     
400082dc:	80 a6 60 00 	cmp  %i1, 0                                    
400082e0:	02 bf ff 95 	be  40008134 <adjtime+0x74>                    
400082e4:	82 10 20 00 	clr  %g1                                       
    *olddelta = *delta;                                               
400082e8:	c4 06 00 00 	ld  [ %i0 ], %g2                               
400082ec:	c4 26 40 00 	st  %g2, [ %i1 ]                               
400082f0:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
400082f4:	c4 26 60 04 	st  %g2, [ %i1 + 4 ]                           
                                                                      
  return 0;                                                           
}                                                                     
400082f8:	81 c7 e0 08 	ret                                            
400082fc:	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 );                   
40008300:	40 00 23 b0 	call  400111c0 <__errno>                       
40008304:	01 00 00 00 	nop                                            
40008308:	84 10 20 16 	mov  0x16, %g2	! 16 <PROM_START+0x16>          
4000830c:	82 10 3f ff 	mov  -1, %g1                                   
40008310:	10 bf ff 8a 	b  40008138 <adjtime+0x78>                     
40008314:	c4 22 00 00 	st  %g2, [ %o0 ]                               
                                                                      

400082cc <aio_cancel>: #include <stdlib.h> #include <rtems/system.h> #include <rtems/seterr.h> int aio_cancel(int fildes, struct aiocb *aiocbp) {
400082cc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request_chain *r_chain;                                   
  int result;                                                         
                                                                      
  pthread_mutex_lock (&aio_request_queue.mutex);                      
400082d0:	3b 10 00 68 	sethi  %hi(0x4001a000), %i5                    
400082d4:	40 00 04 85 	call  400094e8 <pthread_mutex_lock>            
400082d8:	90 17 63 cc 	or  %i5, 0x3cc, %o0	! 4001a3cc <aio_request_queue>
                                                                      
  if (fcntl (fildes, F_GETFD) < 0) {                                  
400082dc:	90 10 00 18 	mov  %i0, %o0                                  
400082e0:	40 00 1b af 	call  4000f19c <fcntl>                         
400082e4:	92 10 20 01 	mov  1, %o1                                    
400082e8:	80 a2 20 00 	cmp  %o0, 0                                    
400082ec:	06 80 00 6c 	bl  4000849c <aio_cancel+0x1d0>                
400082f0:	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) {                                               
400082f4:	02 80 00 3b 	be  400083e0 <aio_cancel+0x114>                
400082f8:	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) {                               
400082fc:	f8 06 40 00 	ld  [ %i1 ], %i4                               
40008300:	80 a7 00 18 	cmp  %i4, %i0                                  
40008304:	12 80 00 2f 	bne  400083c0 <aio_cancel+0xf4>                
40008308:	90 17 63 cc 	or  %i5, 0x3cc, %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);
4000830c:	92 10 00 1c 	mov  %i4, %o1                                  
40008310:	11 10 00 69 	sethi  %hi(0x4001a400), %o0                    
40008314:	94 10 20 00 	clr  %o2                                       
40008318:	40 00 01 92 	call  40008960 <rtems_aio_search_fd>           
4000831c:	90 12 20 14 	or  %o0, 0x14, %o0                             
    if (r_chain == NULL) {                                            
40008320:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40008324:	22 80 00 0f 	be,a   40008360 <aio_cancel+0x94>              
40008328:	b6 17 63 cc 	or  %i5, 0x3cc, %i3                            
        return AIO_ALLDONE;                                           
      }                                                               
    }                                                                 
      AIO_printf ("Request on [WQ]\n");                               
                                                                      
      pthread_mutex_lock (&r_chain->mutex);                           
4000832c:	b8 06 e0 1c 	add  %i3, 0x1c, %i4                            
40008330:	40 00 04 6e 	call  400094e8 <pthread_mutex_lock>            
40008334:	90 10 00 1c 	mov  %i4, %o0                                  
      result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);        
40008338:	92 10 00 19 	mov  %i1, %o1                                  
4000833c:	40 00 01 d2 	call  40008a84 <rtems_aio_remove_req>          
40008340:	90 06 e0 08 	add  %i3, 8, %o0                               
40008344:	b0 10 00 08 	mov  %o0, %i0                                  
      pthread_mutex_unlock (&r_chain->mutex);                         
40008348:	40 00 04 88 	call  40009568 <pthread_mutex_unlock>          
4000834c:	90 10 00 1c 	mov  %i4, %o0                                  
      pthread_mutex_unlock (&aio_request_queue.mutex);                
40008350:	40 00 04 86 	call  40009568 <pthread_mutex_unlock>          
40008354:	90 17 63 cc 	or  %i5, 0x3cc, %o0                            
      return result;                                                  
  }                                                                   
  return AIO_ALLDONE;                                                 
}                                                                     
40008358:	81 c7 e0 08 	ret                                            
4000835c:	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)) {      
40008360:	c4 06 e0 54 	ld  [ %i3 + 0x54 ], %g2                        
40008364:	82 06 e0 58 	add  %i3, 0x58, %g1                            
40008368:	80 a0 80 01 	cmp  %g2, %g1                                  
4000836c:	02 80 00 0f 	be  400083a8 <aio_cancel+0xdc>                 <== NEVER TAKEN
40008370:	90 06 e0 54 	add  %i3, 0x54, %o0                            
        r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40008374:	92 10 00 1c 	mov  %i4, %o1                                  
40008378:	40 00 01 7a 	call  40008960 <rtems_aio_search_fd>           
4000837c:	94 10 20 00 	clr  %o2                                       
        if (r_chain == NULL) {                                        
40008380:	80 a2 20 00 	cmp  %o0, 0                                    
40008384:	02 80 00 0e 	be  400083bc <aio_cancel+0xf0>                 
40008388:	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);      
4000838c:	40 00 01 be 	call  40008a84 <rtems_aio_remove_req>          
40008390:	90 02 20 08 	add  %o0, 8, %o0                               
40008394:	b0 10 00 08 	mov  %o0, %i0                                  
        pthread_mutex_unlock (&aio_request_queue.mutex);              
40008398:	40 00 04 74 	call  40009568 <pthread_mutex_unlock>          
4000839c:	90 10 00 1b 	mov  %i3, %o0                                  
        return result;                                                
400083a0:	81 c7 e0 08 	ret                                            
400083a4:	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;                                         
400083a8:	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);             
400083ac:	40 00 04 6f 	call  40009568 <pthread_mutex_unlock>          
400083b0:	90 17 63 cc 	or  %i5, 0x3cc, %o0                            
          return AIO_ALLDONE;                                         
400083b4:	81 c7 e0 08 	ret                                            
400083b8:	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);            
400083bc:	90 10 00 1b 	mov  %i3, %o0                                  
400083c0:	40 00 04 6a 	call  40009568 <pthread_mutex_unlock>          
400083c4:	b0 10 3f ff 	mov  -1, %i0                                   
          rtems_set_errno_and_return_minus_one (EINVAL);              
400083c8:	40 00 29 9e 	call  40012a40 <__errno>                       
400083cc:	01 00 00 00 	nop                                            
400083d0:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          
400083d4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400083d8:	81 c7 e0 08 	ret                                            
400083dc:	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);
400083e0:	11 10 00 69 	sethi  %hi(0x4001a400), %o0                    
400083e4:	94 10 20 00 	clr  %o2                                       
400083e8:	40 00 01 5e 	call  40008960 <rtems_aio_search_fd>           
400083ec:	90 12 20 14 	or  %o0, 0x14, %o0                             
    if (r_chain == NULL) {                                            
400083f0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
400083f4:	02 80 00 0f 	be  40008430 <aio_cancel+0x164>                
400083f8:	b6 07 20 1c 	add  %i4, 0x1c, %i3                            
      return AIO_ALLDONE;                                             
    }                                                                 
                                                                      
    AIO_printf ("Request chain on [WQ]\n");                           
                                                                      
    pthread_mutex_lock (&r_chain->mutex);                             
400083fc:	40 00 04 3b 	call  400094e8 <pthread_mutex_lock>            
40008400:	90 10 00 1b 	mov  %i3, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
40008404:	40 00 0b 28 	call  4000b0a4 <_Chain_Extract>                
40008408:	90 10 00 1c 	mov  %i4, %o0                                  
    rtems_chain_extract (&r_chain->next_fd);                          
    rtems_aio_remove_fd (r_chain);                                    
4000840c:	40 00 01 8a 	call  40008a34 <rtems_aio_remove_fd>           
40008410:	90 10 00 1c 	mov  %i4, %o0                                  
    pthread_mutex_unlock (&r_chain->mutex);                           
40008414:	40 00 04 55 	call  40009568 <pthread_mutex_unlock>          
40008418:	90 10 00 1b 	mov  %i3, %o0                                  
    pthread_mutex_unlock (&aio_request_queue.mutex);                  
    return AIO_CANCELED;                                              
4000841c:	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);                  
40008420:	40 00 04 52 	call  40009568 <pthread_mutex_unlock>          
40008424:	90 17 63 cc 	or  %i5, 0x3cc, %o0                            
    return AIO_CANCELED;                                              
40008428:	81 c7 e0 08 	ret                                            
4000842c:	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;                    
40008430:	b8 17 63 cc 	or  %i5, 0x3cc, %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)) {      
40008434:	c4 07 20 54 	ld  [ %i4 + 0x54 ], %g2                        
40008438:	82 07 20 58 	add  %i4, 0x58, %g1                            
4000843c:	80 a0 80 01 	cmp  %g2, %g1                                  
40008440:	02 bf ff da 	be  400083a8 <aio_cancel+0xdc>                 <== NEVER TAKEN
40008444:	90 07 20 54 	add  %i4, 0x54, %o0                            
        r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
40008448:	92 10 00 18 	mov  %i0, %o1                                  
4000844c:	40 00 01 45 	call  40008960 <rtems_aio_search_fd>           
40008450:	94 10 20 00 	clr  %o2                                       
        if (r_chain == NULL) {                                        
40008454:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40008458:	22 bf ff d5 	be,a   400083ac <aio_cancel+0xe0>              
4000845c:	b0 10 20 02 	mov  2, %i0                                    
40008460:	40 00 0b 11 	call  4000b0a4 <_Chain_Extract>                
40008464:	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);                                
40008468:	40 00 01 73 	call  40008a34 <rtems_aio_remove_fd>           
4000846c:	90 10 00 1b 	mov  %i3, %o0                                  
        pthread_mutex_destroy (&r_chain->mutex);                      
40008470:	40 00 03 72 	call  40009238 <pthread_mutex_destroy>         
40008474:	90 10 00 1d 	mov  %i5, %o0                                  
        pthread_cond_destroy (&r_chain->mutex);                       
40008478:	40 00 02 94 	call  40008ec8 <pthread_cond_destroy>          
4000847c:	90 10 00 1d 	mov  %i5, %o0                                  
        free (r_chain);                                               
40008480:	7f ff f0 17 	call  400044dc <free>                          
40008484:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
        pthread_mutex_unlock (&aio_request_queue.mutex);              
        return AIO_CANCELED;                                          
40008488:	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);              
4000848c:	40 00 04 37 	call  40009568 <pthread_mutex_unlock>          
40008490:	90 10 00 1c 	mov  %i4, %o0                                  
        return AIO_CANCELED;                                          
40008494:	81 c7 e0 08 	ret                                            
40008498:	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);                   
4000849c:	40 00 04 33 	call  40009568 <pthread_mutex_unlock>          
400084a0:	90 17 63 cc 	or  %i5, 0x3cc, %o0                            
    rtems_set_errno_and_return_minus_one (EBADF);                     
400084a4:	40 00 29 67 	call  40012a40 <__errno>                       
400084a8:	b0 10 3f ff 	mov  -1, %i0                                   
400084ac:	82 10 20 09 	mov  9, %g1                                    
400084b0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400084b4:	81 c7 e0 08 	ret                                            
400084b8:	81 e8 00 00 	restore                                        
                                                                      

400084c4 <aio_fsync>: int aio_fsync( int op, struct aiocb *aiocbp ) {
400084c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  if (op != O_SYNC)                                                   
400084c8:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
400084cc:	80 a6 00 01 	cmp  %i0, %g1                                  
400084d0:	12 80 00 14 	bne  40008520 <aio_fsync+0x5c>                 
400084d4:	ba 10 20 16 	mov  0x16, %i5                                 
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
400084d8:	d0 06 40 00 	ld  [ %i1 ], %o0                               
400084dc:	40 00 1b 30 	call  4000f19c <fcntl>                         
400084e0:	92 10 20 03 	mov  3, %o1                                    
  if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
400084e4:	90 0a 20 03 	and  %o0, 3, %o0                               
400084e8:	90 02 3f ff 	add  %o0, -1, %o0                              
400084ec:	80 a2 20 01 	cmp  %o0, 1                                    
400084f0:	18 80 00 0c 	bgu  40008520 <aio_fsync+0x5c>                 
400084f4:	ba 10 20 09 	mov  9, %i5                                    
    rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);             
                                                                      
  req = malloc (sizeof (rtems_aio_request));                          
400084f8:	7f ff f1 20 	call  40004978 <malloc>                        
400084fc:	90 10 20 18 	mov  0x18, %o0                                 
  if (req == NULL)                                                    
40008500:	80 a2 20 00 	cmp  %o0, 0                                    
40008504:	02 80 00 06 	be  4000851c <aio_fsync+0x58>                  <== NEVER TAKEN
40008508:	82 10 20 03 	mov  3, %g1                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
                                                                      
  req->aiocbp = aiocbp;                                               
4000850c:	f2 22 20 14 	st  %i1, [ %o0 + 0x14 ]                        
  req->aiocbp->aio_lio_opcode = LIO_SYNC;                             
40008510:	c2 26 60 30 	st  %g1, [ %i1 + 0x30 ]                        
                                                                      
  return rtems_aio_enqueue (req);                                     
40008514:	40 00 01 78 	call  40008af4 <rtems_aio_enqueue>             
40008518:	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);            
4000851c:	ba 10 20 0b 	mov  0xb, %i5                                  <== NOT EXECUTED
40008520:	82 10 3f ff 	mov  -1, %g1                                   
40008524:	fa 26 60 34 	st  %i5, [ %i1 + 0x34 ]                        
40008528:	c2 26 60 38 	st  %g1, [ %i1 + 0x38 ]                        
4000852c:	40 00 29 45 	call  40012a40 <__errno>                       
40008530:	b0 10 3f ff 	mov  -1, %i0                                   
40008534:	fa 22 00 00 	st  %i5, [ %o0 ]                               
  req->aiocbp = aiocbp;                                               
  req->aiocbp->aio_lio_opcode = LIO_SYNC;                             
                                                                      
  return rtems_aio_enqueue (req);                                     
                                                                      
}                                                                     
40008538:	81 c7 e0 08 	ret                                            
4000853c:	81 e8 00 00 	restore                                        
                                                                      

40008cd8 <aio_read>: * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) {
40008cd8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
40008cdc:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40008ce0:	92 10 20 03 	mov  3, %o1                                    
40008ce4:	40 00 19 2e 	call  4000f19c <fcntl>                         
40008ce8:	ba 10 20 09 	mov  9, %i5                                    
  if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40008cec:	80 8a 20 01 	btst  1, %o0                                   
40008cf0:	12 80 00 0b 	bne  40008d1c <aio_read+0x44>                  
40008cf4:	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)
40008cf8:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
40008cfc:	80 a0 60 00 	cmp  %g1, 0                                    
40008d00:	12 80 00 06 	bne  40008d18 <aio_read+0x40>                  
40008d04:	ba 10 20 16 	mov  0x16, %i5                                 
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
40008d08:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40008d0c:	80 a0 60 00 	cmp  %g1, 0                                    
40008d10:	16 80 00 0a 	bge  40008d38 <aio_read+0x60>                  
40008d14:	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);            
40008d18:	82 10 3f ff 	mov  -1, %g1	! ffffffff <LEON_REG+0x7fffffff>  
40008d1c:	fa 26 20 34 	st  %i5, [ %i0 + 0x34 ]                        
40008d20:	c2 26 20 38 	st  %g1, [ %i0 + 0x38 ]                        
40008d24:	40 00 27 47 	call  40012a40 <__errno>                       
40008d28:	b0 10 3f ff 	mov  -1, %i0                                   
40008d2c:	fa 22 00 00 	st  %i5, [ %o0 ]                               
                                                                      
  req->aiocbp = aiocbp;                                               
  req->aiocbp->aio_lio_opcode = LIO_READ;                             
                                                                      
  return rtems_aio_enqueue (req);                                     
}                                                                     
40008d30:	81 c7 e0 08 	ret                                            
40008d34:	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));                          
40008d38:	7f ff ef 10 	call  40004978 <malloc>                        
40008d3c:	90 10 20 18 	mov  0x18, %o0                                 
  if (req == NULL)                                                    
40008d40:	80 a2 20 00 	cmp  %o0, 0                                    
40008d44:	02 80 00 06 	be  40008d5c <aio_read+0x84>                   <== NEVER TAKEN
40008d48:	82 10 20 01 	mov  1, %g1                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
                                                                      
  req->aiocbp = aiocbp;                                               
40008d4c:	f0 22 20 14 	st  %i0, [ %o0 + 0x14 ]                        
  req->aiocbp->aio_lio_opcode = LIO_READ;                             
40008d50:	c2 26 20 30 	st  %g1, [ %i0 + 0x30 ]                        
                                                                      
  return rtems_aio_enqueue (req);                                     
40008d54:	7f ff ff 68 	call  40008af4 <rtems_aio_enqueue>             
40008d58:	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);            
40008d5c:	10 bf ff ef 	b  40008d18 <aio_read+0x40>                    <== NOT EXECUTED
40008d60:	ba 10 20 0b 	mov  0xb, %i5                                  <== NOT EXECUTED
                                                                      

40008d6c <aio_write>: * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) {
40008d6c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_aio_request *req;                                             
  int mode;                                                           
                                                                      
  mode = fcntl (aiocbp->aio_fildes, F_GETFL);                         
40008d70:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40008d74:	40 00 19 0a 	call  4000f19c <fcntl>                         
40008d78:	92 10 20 03 	mov  3, %o1                                    
  if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40008d7c:	90 0a 20 03 	and  %o0, 3, %o0                               
40008d80:	90 02 3f ff 	add  %o0, -1, %o0                              
40008d84:	80 a2 20 01 	cmp  %o0, 1                                    
40008d88:	18 80 00 0a 	bgu  40008db0 <aio_write+0x44>                 
40008d8c:	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)
40008d90:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
40008d94:	80 a0 60 00 	cmp  %g1, 0                                    
40008d98:	12 80 00 06 	bne  40008db0 <aio_write+0x44>                 
40008d9c:	ba 10 20 16 	mov  0x16, %i5                                 
    rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);            
                                                                      
  if (aiocbp->aio_offset < 0)                                         
40008da0:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40008da4:	80 a0 60 00 	cmp  %g1, 0                                    
40008da8:	16 80 00 0a 	bge  40008dd0 <aio_write+0x64>                 
40008dac:	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);            
40008db0:	82 10 3f ff 	mov  -1, %g1	! ffffffff <LEON_REG+0x7fffffff>  
40008db4:	fa 26 20 34 	st  %i5, [ %i0 + 0x34 ]                        
40008db8:	c2 26 20 38 	st  %g1, [ %i0 + 0x38 ]                        
40008dbc:	40 00 27 21 	call  40012a40 <__errno>                       
40008dc0:	b0 10 3f ff 	mov  -1, %i0                                   
40008dc4:	fa 22 00 00 	st  %i5, [ %o0 ]                               
                                                                      
  req->aiocbp = aiocbp;                                               
  req->aiocbp->aio_lio_opcode = LIO_WRITE;                            
                                                                      
  return rtems_aio_enqueue (req);                                     
}                                                                     
40008dc8:	81 c7 e0 08 	ret                                            
40008dcc:	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));                          
40008dd0:	7f ff ee ea 	call  40004978 <malloc>                        
40008dd4:	90 10 20 18 	mov  0x18, %o0                                 
  if (req == NULL)                                                    
40008dd8:	80 a2 20 00 	cmp  %o0, 0                                    
40008ddc:	02 80 00 06 	be  40008df4 <aio_write+0x88>                  <== NEVER TAKEN
40008de0:	82 10 20 02 	mov  2, %g1                                    
    rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);            
                                                                      
  req->aiocbp = aiocbp;                                               
40008de4:	f0 22 20 14 	st  %i0, [ %o0 + 0x14 ]                        
  req->aiocbp->aio_lio_opcode = LIO_WRITE;                            
40008de8:	c2 26 20 30 	st  %g1, [ %i0 + 0x30 ]                        
                                                                      
  return rtems_aio_enqueue (req);                                     
40008dec:	7f ff ff 42 	call  40008af4 <rtems_aio_enqueue>             
40008df0:	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);            
40008df4:	10 bf ff ef 	b  40008db0 <aio_write+0x44>                   <== NOT EXECUTED
40008df8:	ba 10 20 0b 	mov  0xb, %i5                                  <== NOT EXECUTED
                                                                      

4000932c <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)) {
4000932c:	80 a2 ff f8 	cmp  %o3, -8                                   
40009330:	02 80 00 23 	be  400093bc <check_and_merge+0x90>            
40009334:	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);            
40009338:	c2 02 c0 00 	ld  [ %o3 ], %g1                               
4000933c:	80 a0 60 00 	cmp  %g1, 0                                    
40009340:	22 80 00 1c 	be,a   400093b0 <check_and_merge+0x84>         
40009344:	c4 02 e0 04 	ld  [ %o3 + 4 ], %g2                           
    if (b->begin < a->begin) {                                        
40009348:	c6 02 e0 18 	ld  [ %o3 + 0x18 ], %g3                        
4000934c:	c4 02 a0 18 	ld  [ %o2 + 0x18 ], %g2                        
40009350:	80 a0 c0 02 	cmp  %g3, %g2                                  
40009354:	3a 80 00 07 	bcc,a   40009370 <check_and_merge+0x44>        
40009358:	c8 02 a0 1c 	ld  [ %o2 + 0x1c ], %g4                        
4000935c:	84 10 00 0a 	mov  %o2, %g2                                  
40009360:	c2 02 80 00 	ld  [ %o2 ], %g1                               
40009364:	94 10 00 0b 	mov  %o3, %o2                                  
40009368:	96 10 00 02 	mov  %g2, %o3                                  
                                                                      
      a = b;                                                          
      b = t;                                                          
    }                                                                 
                                                                      
    a->size += b->size;                                               
4000936c:	c8 02 a0 1c 	ld  [ %o2 + 0x1c ], %g4                        
40009370:	c6 02 e0 1c 	ld  [ %o3 + 0x1c ], %g3                        
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
40009374:	c4 02 e0 04 	ld  [ %o3 + 4 ], %g2                           
40009378:	86 01 00 03 	add  %g4, %g3, %g3                             
4000937c:	c6 22 a0 1c 	st  %g3, [ %o2 + 0x1c ]                        
  next->previous = previous;                                          
  previous->next = next;                                              
40009380:	c2 20 80 00 	st  %g1, [ %g2 ]                               
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
  next->previous = previous;                                          
40009384:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
40009388:	c2 02 00 00 	ld  [ %o0 ], %g1                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000938c:	d0 22 e0 04 	st  %o0, [ %o3 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
40009390:	d6 22 00 00 	st  %o3, [ %o0 ]                               
  the_node->next        = before_node;                                
40009394:	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);           
40009398:	90 10 00 09 	mov  %o1, %o0                                  
  before_node->previous = the_node;                                   
4000939c:	d6 20 60 04 	st  %o3, [ %g1 + 4 ]                           
400093a0:	92 02 e0 08 	add  %o3, 8, %o1                               
400093a4:	82 13 c0 00 	mov  %o7, %g1                                  
400093a8:	40 00 07 13 	call  4000aff4 <_RBTree_Extract_unprotected>   
400093ac:	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);            
400093b0:	80 a0 a0 00 	cmp  %g2, 0                                    
400093b4:	32 bf ff e6 	bne,a   4000934c <check_and_merge+0x20>        <== NEVER TAKEN
400093b8:	c6 02 e0 18 	ld  [ %o3 + 0x18 ], %g3                        <== NOT EXECUTED
400093bc:	81 c3 e0 08 	retl                                           
                                                                      

40004950 <chroot>: #include <unistd.h> #include <rtems/libio_.h> int chroot( const char *path ) {
40004950:	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(             
40004954:	94 10 20 19 	mov  0x19, %o2                                 
40004958:	92 10 00 18 	mov  %i0, %o1                                  
4000495c:	90 07 bf c8 	add  %fp, -56, %o0                             
40004960:	17 10 00 4d 	sethi  %hi(0x40013400), %o3                    
40004964:	96 12 e2 10 	or  %o3, 0x210, %o3	! 40013610 <rtems_global_user_env+0x4>
40004968:	40 00 04 f3 	call  40005d34 <rtems_filesystem_eval_path_start_with_root_and_current>
4000496c:	98 02 ff fc 	add  %o3, -4, %o4                              
40004970:	92 07 bf e0 	add  %fp, -32, %o1                             
40004974:	40 00 06 0b 	call  400061a0 <rtems_filesystem_location_copy_and_detach>
40004978:	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 );
4000497c:	40 00 06 98 	call  400063dc <rtems_filesystem_location_transform_to_global>
40004980:	90 07 bf b0 	add  %fp, -80, %o0                             
  if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
40004984:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
40004988:	39 10 00 4b 	sethi  %hi(0x40012c00), %i4                    
4000498c:	b8 17 22 d4 	or  %i4, 0x2d4, %i4	! 40012ed4 <rtems_filesystem_null_handlers>
40004990:	80 a0 40 1c 	cmp  %g1, %i4                                  
40004994:	02 80 00 16 	be  400049ec <chroot+0x9c>                     
40004998:	d0 27 bf ac 	st  %o0, [ %fp + -84 ]                         
    rtems_filesystem_global_location_t *new_root_loc =                
4000499c:	40 00 06 56 	call  400062f4 <rtems_filesystem_global_location_obtain>
400049a0:	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)(           
400049a4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
400049a8:	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 =                              
400049ac:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
400049b0:	9f c0 40 00 	call  %g1                                      
400049b4:	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 ) {                       
400049b8:	80 a2 20 00 	cmp  %o0, 0                                    
400049bc:	02 80 00 13 	be  40004a08 <chroot+0xb8>                     
400049c0:	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 ) ) {                  
400049c4:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
400049c8:	80 a0 40 1c 	cmp  %g1, %i4                                  
400049cc:	02 80 00 06 	be  400049e4 <chroot+0x94>                     <== NEVER TAKEN
400049d0:	01 00 00 00 	nop                                            
    errno = eno;                                                      
400049d4:	40 00 21 ac 	call  4000d084 <__errno>                       
400049d8:	01 00 00 00 	nop                                            
400049dc:	82 10 20 14 	mov  0x14, %g1	! 14 <PROM_START+0x14>          
400049e0:	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 );       
400049e4:	40 00 06 24 	call  40006274 <rtems_filesystem_global_location_release>
400049e8:	90 10 00 1d 	mov  %i5, %o0                                  
    }                                                                 
  } else {                                                            
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
400049ec:	40 00 05 1c 	call  40005e5c <rtems_filesystem_eval_path_cleanup>
400049f0:	90 07 bf c8 	add  %fp, -56, %o0                             
                                                                      
  if ( rv != 0 ) {                                                    
    rtems_filesystem_global_location_release( new_current_loc );      
400049f4:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
400049f8:	40 00 06 1f 	call  40006274 <rtems_filesystem_global_location_release>
400049fc:	b0 10 3f ff 	mov  -1, %i0                                   
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40004a00:	81 c7 e0 08 	ret                                            
40004a04:	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();                             
40004a08:	40 00 03 11 	call  4000564c <rtems_libio_set_private_env>   
40004a0c:	01 00 00 00 	nop                                            
      if (sc == RTEMS_SUCCESSFUL) {                                   
40004a10:	80 a2 20 00 	cmp  %o0, 0                                    
40004a14:	02 80 00 09 	be  40004a38 <chroot+0xe8>                     
40004a18:	80 a2 20 0d 	cmp  %o0, 0xd                                  
        rtems_filesystem_global_location_assign(                      
          &rtems_filesystem_current,                                  
          new_current_loc                                             
        );                                                            
      } else {                                                        
        if (sc != RTEMS_UNSATISFIED) {                                
40004a1c:	02 bf ff f2 	be  400049e4 <chroot+0x94>                     <== NEVER TAKEN
40004a20:	01 00 00 00 	nop                                            
          errno = ENOMEM;                                             
40004a24:	40 00 21 98 	call  4000d084 <__errno>                       
40004a28:	01 00 00 00 	nop                                            
40004a2c:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             
40004a30:	10 bf ff ed 	b  400049e4 <chroot+0x94>                      
40004a34:	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(                      
40004a38:	39 10 00 4d 	sethi  %hi(0x40013400), %i4                    
40004a3c:	d0 07 22 08 	ld  [ %i4 + 0x208 ], %o0	! 40013608 <rtems_current_user_env>
40004a40:	92 10 00 1d 	mov  %i5, %o1                                  
40004a44:	40 00 06 22 	call  400062cc <rtems_filesystem_global_location_assign>
40004a48:	90 02 20 04 	add  %o0, 4, %o0                               
          &rtems_filesystem_root,                                     
          new_root_loc                                                
        );                                                            
        rtems_filesystem_global_location_assign(                      
40004a4c:	d2 07 bf ac 	ld  [ %fp + -84 ], %o1                         
40004a50:	d0 07 22 08 	ld  [ %i4 + 0x208 ], %o0                       
40004a54:	40 00 06 1e 	call  400062cc <rtems_filesystem_global_location_assign>
40004a58:	b0 10 20 00 	clr  %i0                                       
    }                                                                 
  } else {                                                            
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40004a5c:	40 00 05 00 	call  40005e5c <rtems_filesystem_eval_path_cleanup>
40004a60:	90 07 bf c8 	add  %fp, -56, %o0                             
40004a64:	81 c7 e0 08 	ret                                            
40004a68:	81 e8 00 00 	restore                                        
                                                                      

40007f2c <clock_gettime>: int clock_gettime( clockid_t clock_id, struct timespec *tp ) {
40007f2c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ( !tp )                                                          
40007f30:	80 a6 60 00 	cmp  %i1, 0                                    
40007f34:	02 80 00 0a 	be  40007f5c <clock_gettime+0x30>              
40007f38:	80 a6 20 01 	cmp  %i0, 1                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME ) {                                 
40007f3c:	02 80 00 19 	be  40007fa0 <clock_gettime+0x74>              
40007f40:	80 a6 20 04 	cmp  %i0, 4                                    
    _TOD_Get(tp);                                                     
    return 0;                                                         
  }                                                                   
#ifdef CLOCK_MONOTONIC                                                
  if ( clock_id == CLOCK_MONOTONIC ) {                                
40007f44:	02 80 00 12 	be  40007f8c <clock_gettime+0x60>              <== NEVER TAKEN
40007f48:	80 a6 20 02 	cmp  %i0, 2                                    
    return 0;                                                         
  }                                                                   
#endif                                                                
                                                                      
#ifdef _POSIX_CPUTIME                                                 
  if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {                       
40007f4c:	02 80 00 10 	be  40007f8c <clock_gettime+0x60>              
40007f50:	80 a6 20 03 	cmp  %i0, 3                                    
    return 0;                                                         
  }                                                                   
#endif                                                                
                                                                      
#ifdef _POSIX_THREAD_CPUTIME                                          
  if ( clock_id == CLOCK_THREAD_CPUTIME_ID )                          
40007f54:	02 80 00 08 	be  40007f74 <clock_gettime+0x48>              
40007f58:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
40007f5c:	40 00 25 fa 	call  40011744 <__errno>                       
40007f60:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  
40007f64:	82 10 20 16 	mov  0x16, %g1                                 
40007f68:	c2 22 00 00 	st  %g1, [ %o0 ]                               
                                                                      
  return 0;                                                           
}                                                                     
40007f6c:	81 c7 e0 08 	ret                                            
40007f70:	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 );                   
40007f74:	40 00 25 f4 	call  40011744 <__errno>                       
40007f78:	b0 10 3f ff 	mov  -1, %i0                                   
40007f7c:	82 10 20 58 	mov  0x58, %g1                                 
40007f80:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40007f84:	81 c7 e0 08 	ret                                            
40007f88:	81 e8 00 00 	restore                                        
    _TOD_Get(tp);                                                     
    return 0;                                                         
  }                                                                   
#ifdef CLOCK_MONOTONIC                                                
  if ( clock_id == CLOCK_MONOTONIC ) {                                
    _TOD_Get_uptime_as_timespec( tp );                                
40007f8c:	90 10 00 19 	mov  %i1, %o0                                  
40007f90:	40 00 08 a4 	call  4000a220 <_TOD_Get_uptime_as_timespec>   
40007f94:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
40007f98:	81 c7 e0 08 	ret                                            
40007f9c:	81 e8 00 00 	restore                                        
)                                                                     
{                                                                     
  Timestamp_Control  tod_as_timestamp;                                
  Timestamp_Control *tod_as_timestamp_ptr;                            
                                                                      
  tod_as_timestamp_ptr =                                              
40007fa0:	90 07 bf f8 	add  %fp, -8, %o0                              
40007fa4:	13 10 00 6d 	sethi  %hi(0x4001b400), %o1                    
40007fa8:	40 00 08 8d 	call  4000a1dc <_TOD_Get_with_nanoseconds>     
40007fac:	92 12 63 38 	or  %o1, 0x338, %o1	! 4001b738 <_TOD>          
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
                                                                      
  return 0;                                                           
}                                                                     
40007fb0:	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);           
40007fb4:	94 10 20 00 	clr  %o2                                       
40007fb8:	90 10 00 1c 	mov  %i4, %o0                                  
40007fbc:	92 10 00 1d 	mov  %i5, %o1                                  
40007fc0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40007fc4:	40 00 3e 50 	call  40017904 <__divdi3>                      
40007fc8:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40007fcc:	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);           
40007fd0:	d2 26 40 00 	st  %o1, [ %i1 ]                               
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40007fd4:	90 10 00 1c 	mov  %i4, %o0                                  
40007fd8:	92 10 00 1d 	mov  %i5, %o1                                  
40007fdc:	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;                                                         
40007fe0:	b0 10 20 00 	clr  %i0                                       
40007fe4:	40 00 3f 33 	call  40017cb0 <__moddi3>                      
40007fe8:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40007fec:	d2 26 60 04 	st  %o1, [ %i1 + 4 ]                           
40007ff0:	81 c7 e0 08 	ret                                            
40007ff4:	81 e8 00 00 	restore                                        
                                                                      

40029a84 <clock_settime>: int clock_settime( clockid_t clock_id, const struct timespec *tp ) {
40029a84:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ( !tp )                                                          
40029a88:	80 a6 60 00 	cmp  %i1, 0                                    
40029a8c:	02 80 00 08 	be  40029aac <clock_settime+0x28>              <== NEVER TAKEN
40029a90:	80 a6 20 01 	cmp  %i0, 1                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( clock_id == CLOCK_REALTIME ) {                                 
40029a94:	02 80 00 0c 	be  40029ac4 <clock_settime+0x40>              
40029a98:	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 )                    
40029a9c:	02 80 00 49 	be  40029bc0 <clock_settime+0x13c>             
40029aa0:	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 )                     
40029aa4:	02 80 00 47 	be  40029bc0 <clock_settime+0x13c>             
40029aa8:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( ENOSYS );                   
#endif                                                                
  else                                                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
40029aac:	40 00 4b 2f 	call  4003c768 <__errno>                       
40029ab0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  
40029ab4:	82 10 20 16 	mov  0x16, %g1                                 
40029ab8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
                                                                      
  return 0;                                                           
}                                                                     
40029abc:	81 c7 e0 08 	ret                                            
40029ac0:	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 )                 
40029ac4:	c4 06 40 00 	ld  [ %i1 ], %g2                               
40029ac8:	03 08 76 b9 	sethi  %hi(0x21dae400), %g1                    
40029acc:	82 10 60 ff 	or  %g1, 0xff, %g1	! 21dae4ff <RAM_SIZE+0x219ae4ff>
40029ad0:	80 a0 80 01 	cmp  %g2, %g1                                  
40029ad4:	08 bf ff f6 	bleu  40029aac <clock_settime+0x28>            
40029ad8:	03 10 01 a6 	sethi  %hi(0x40069800), %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;                  
40029adc:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2	! 40069890 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
40029ae0:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40029ae4:	c4 20 60 90 	st  %g2, [ %g1 + 0x90 ]                        
  const struct timespec *tod_as_timespec                              
)                                                                     
{                                                                     
  Timestamp_Control tod_as_timestamp;                                 
                                                                      
  _Timestamp_Set(                                                     
40029ae8:	c6 06 40 00 	ld  [ %i1 ], %g3                               
40029aec:	e2 06 60 04 	ld  [ %i1 + 4 ], %l1                           
40029af0:	85 38 e0 1f 	sra  %g3, 0x1f, %g2                            
  Timestamp64_Control *_time,                                         
  Timestamp64_Control  _seconds,                                      
  Timestamp64_Control  _nanoseconds                                   
)                                                                     
{                                                                     
  *_time = _seconds * 1000000000L + _nanoseconds;                     
40029af4:	83 28 a0 03 	sll  %g2, 3, %g1                               
40029af8:	bb 28 e0 03 	sll  %g3, 3, %i5                               
40029afc:	89 30 e0 1d 	srl  %g3, 0x1d, %g4                            
40029b00:	b8 11 00 01 	or  %g4, %g1, %i4                              
40029b04:	83 37 60 1b 	srl  %i5, 0x1b, %g1                            
40029b08:	a5 2f 20 05 	sll  %i4, 5, %l2                               
40029b0c:	a7 2f 60 05 	sll  %i5, 5, %l3                               
40029b10:	a4 10 40 12 	or  %g1, %l2, %l2                              
40029b14:	ba a4 c0 1d 	subcc  %l3, %i5, %i5                           
40029b18:	83 37 60 1a 	srl  %i5, 0x1a, %g1                            
40029b1c:	b8 64 80 1c 	subx  %l2, %i4, %i4                            
40029b20:	97 2f 60 06 	sll  %i5, 6, %o3                               
40029b24:	95 2f 20 06 	sll  %i4, 6, %o2                               
40029b28:	ba a2 c0 1d 	subcc  %o3, %i5, %i5                           
40029b2c:	94 10 40 0a 	or  %g1, %o2, %o2                              
40029b30:	b8 62 80 1c 	subx  %o2, %i4, %i4                            
40029b34:	aa 87 40 03 	addcc  %i5, %g3, %l5                           
40029b38:	83 35 60 1e 	srl  %l5, 0x1e, %g1                            
40029b3c:	a8 47 00 02 	addx  %i4, %g2, %l4                            
40029b40:	9b 2d 60 02 	sll  %l5, 2, %o5                               
40029b44:	99 2d 20 02 	sll  %l4, 2, %o4                               
40029b48:	86 85 40 0d 	addcc  %l5, %o5, %g3                           
40029b4c:	98 10 40 0c 	or  %g1, %o4, %o4                              
40029b50:	b3 28 e0 02 	sll  %g3, 2, %i1                               
40029b54:	84 45 00 0c 	addx  %l4, %o4, %g2                            
40029b58:	83 30 e0 1e 	srl  %g3, 0x1e, %g1                            
40029b5c:	ba 80 c0 19 	addcc  %g3, %i1, %i5                           
40029b60:	b1 28 a0 02 	sll  %g2, 2, %i0                               
40029b64:	b7 2f 60 02 	sll  %i5, 2, %i3                               
40029b68:	b0 10 40 18 	or  %g1, %i0, %i0                              
40029b6c:	83 37 60 1e 	srl  %i5, 0x1e, %g1                            
40029b70:	b8 40 80 18 	addx  %g2, %i0, %i4                            
40029b74:	86 87 40 1b 	addcc  %i5, %i3, %g3                           
40029b78:	b5 2f 20 02 	sll  %i4, 2, %i2                               
40029b7c:	bb 30 e0 17 	srl  %g3, 0x17, %i5                            
40029b80:	b4 10 40 1a 	or  %g1, %i2, %i2                              
40029b84:	84 47 00 1a 	addx  %i4, %i2, %g2                            
40029b88:	83 28 e0 09 	sll  %g3, 9, %g1                               
40029b8c:	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 );                       
40029b90:	90 07 bf f8 	add  %fp, -8, %o0                              
40029b94:	84 17 40 04 	or  %i5, %g4, %g2                              
40029b98:	ba 84 40 01 	addcc  %l1, %g1, %i5                           
  const struct timespec *tod_as_timespec                              
)                                                                     
{                                                                     
  Timestamp_Control tod_as_timestamp;                                 
                                                                      
  _Timestamp_Set(                                                     
40029b9c:	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;                                                           
40029ba0:	b0 10 20 00 	clr  %i0                                       
40029ba4:	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 );                       
40029ba8:	40 00 04 92 	call  4002adf0 <_TOD_Set_with_timestamp>       
40029bac:	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();                                        
40029bb0:	7f ff 83 a7 	call  4000aa4c <_Thread_Enable_dispatch>       
40029bb4:	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;                                                           
40029bb8:	81 c7 e0 08 	ret                                            
40029bbc:	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 );                   
40029bc0:	40 00 4a ea 	call  4003c768 <__errno>                       
40029bc4:	b0 10 3f ff 	mov  -1, %i0                                   
40029bc8:	82 10 20 58 	mov  0x58, %g1                                 
40029bcc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40029bd0:	81 c7 e0 08 	ret                                            
40029bd4:	81 e8 00 00 	restore                                        
                                                                      

40004264 <create_disk>: dev_t dev, const char *name, rtems_disk_device **dd_ptr, char **alloc_name_ptr ) {
40004264:	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) {                                        
40004268:	25 10 00 71 	sethi  %hi(0x4001c400), %l2                    
4000426c:	fa 04 a0 70 	ld  [ %l2 + 0x70 ], %i5	! 4001c470 <disktab_size>
40004270:	80 a6 00 1d 	cmp  %i0, %i5                                  
40004274:	1a 80 00 30 	bcc  40004334 <create_disk+0xd0>               
40004278:	a2 10 00 18 	mov  %i0, %l1                                  
4000427c:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
40004280:	e0 00 60 74 	ld  [ %g1 + 0x74 ], %l0	! 4001c474 <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) {
40004284:	83 2c 60 03 	sll  %l1, 3, %g1                               
40004288:	fa 04 00 01 	ld  [ %l0 + %g1 ], %i5                         
4000428c:	a0 04 00 01 	add  %l0, %g1, %l0                             
40004290:	80 a7 60 00 	cmp  %i5, 0                                    
40004294:	02 80 00 0f 	be  400042d0 <create_disk+0x6c>                
40004298:	f0 04 20 04 	ld  [ %l0 + 4 ], %i0                           
4000429c:	80 a6 40 18 	cmp  %i1, %i0                                  
400042a0:	1a 80 00 0d 	bcc  400042d4 <create_disk+0x70>               
400042a4:	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;                               
400042a8:	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) {                                             
400042ac:	a0 87 40 01 	addcc  %i5, %g1, %l0                           
400042b0:	02 80 00 1f 	be  4000432c <create_disk+0xc8>                <== NEVER TAKEN
400042b4:	01 00 00 00 	nop                                            
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  if (*dd_entry != NULL) {                                            
400042b8:	c2 07 40 01 	ld  [ %i5 + %g1 ], %g1                         
400042bc:	80 a0 60 00 	cmp  %g1, 0                                    
400042c0:	02 80 00 36 	be  40004398 <create_disk+0x134>               
400042c4:	b0 10 20 0c 	mov  0xc, %i0                                  
  *dd_entry = dd;                                                     
  *dd_ptr = dd;                                                       
  *alloc_name_ptr = alloc_name;                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400042c8:	81 c7 e0 08 	ret                                            
400042cc:	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) {                                              
400042d0:	80 a6 20 00 	cmp  %i0, 0                                    
400042d4:	12 80 00 2b 	bne  40004380 <create_disk+0x11c>              
400042d8:	a4 10 20 08 	mov  8, %l2                                    
      new_size = DISKTAB_INITIAL_SIZE;                                
    } else {                                                          
      new_size = 2 * old_size;                                        
    }                                                                 
    if (minor >= new_size) {                                          
400042dc:	80 a6 40 12 	cmp  %i1, %l2                                  
400042e0:	3a 80 00 02 	bcc,a   400042e8 <create_disk+0x84>            
400042e4:	a4 06 60 01 	add  %i1, 1, %l2                               
      new_size = minor + 1;                                           
    }                                                                 
                                                                      
    table = realloc(table, new_size * sizeof(*table));                
400042e8:	90 10 00 1d 	mov  %i5, %o0                                  
400042ec:	40 00 08 12 	call  40006334 <realloc>                       
400042f0:	93 2c a0 02 	sll  %l2, 2, %o1                               
    if (table == NULL) {                                              
400042f4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400042f8:	02 80 00 0d 	be  4000432c <create_disk+0xc8>                
400042fc:	94 24 80 18 	sub  %l2, %i0, %o2                             
      return NULL;                                                    
    }                                                                 
                                                                      
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40004300:	91 2e 20 02 	sll  %i0, 2, %o0                               
40004304:	92 10 20 00 	clr  %o1                                       
40004308:	90 07 40 08 	add  %i5, %o0, %o0                             
4000430c:	40 00 46 6f 	call  40015cc8 <memset>                        
40004310:	95 2a a0 02 	sll  %o2, 2, %o2                               
    disktab [major].minor = table;                                    
40004314:	fa 24 00 00 	st  %i5, [ %l0 ]                               
    disktab [major].size = new_size;                                  
40004318:	e4 24 20 04 	st  %l2, [ %l0 + 4 ]                           
  }                                                                   
                                                                      
  return disktab [major].minor + minor;                               
4000431c:	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) {                                             
40004320:	a0 87 40 01 	addcc  %i5, %g1, %l0                           
40004324:	32 bf ff e6 	bne,a   400042bc <create_disk+0x58>            <== ALWAYS TAKEN
40004328:	c2 07 40 01 	ld  [ %i5 + %g1 ], %g1                         
    alloc_name = strdup(name);                                        
                                                                      
    if (alloc_name == NULL) {                                         
      free(dd);                                                       
                                                                      
      return RTEMS_NO_MEMORY;                                         
4000432c:	81 c7 e0 08 	ret                                            
40004330:	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;                         
40004334:	27 10 00 71 	sethi  %hi(0x4001c400), %l3                    
    rtems_device_major_number old_size = disktab_size;                
    rtems_device_major_number new_size = 2 * old_size;                
40004338:	b1 2f 60 01 	sll  %i5, 1, %i0                               
                                                                      
    if (major >= new_size) {                                          
4000433c:	80 a4 40 18 	cmp  %l1, %i0                                  
40004340:	0a 80 00 03 	bcs  4000434c <create_disk+0xe8>               <== NEVER TAKEN
40004344:	d0 04 e0 74 	ld  [ %l3 + 0x74 ], %o0                        
      new_size = major + 1;                                           
40004348:	b0 04 60 01 	add  %l1, 1, %i0                               
    }                                                                 
                                                                      
    table = realloc(table, new_size * sizeof(*table));                
4000434c:	40 00 07 fa 	call  40006334 <realloc>                       
40004350:	93 2e 20 03 	sll  %i0, 3, %o1                               
    if (table == NULL) {                                              
40004354:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40004358:	02 bf ff f5 	be  4000432c <create_disk+0xc8>                <== ALWAYS TAKEN
4000435c:	94 26 00 1d 	sub  %i0, %i5, %o2                             
      return NULL;                                                    
    }                                                                 
                                                                      
    memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
40004360:	91 2f 60 03 	sll  %i5, 3, %o0                               <== NOT EXECUTED
40004364:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40004368:	90 04 00 08 	add  %l0, %o0, %o0                             <== NOT EXECUTED
4000436c:	40 00 46 57 	call  40015cc8 <memset>                        <== NOT EXECUTED
40004370:	95 2a a0 03 	sll  %o2, 3, %o2                               <== NOT EXECUTED
    disktab = table;                                                  
40004374:	e0 24 e0 74 	st  %l0, [ %l3 + 0x74 ]                        <== NOT EXECUTED
    disktab_size = new_size;                                          
40004378:	10 bf ff c3 	b  40004284 <create_disk+0x20>                 <== NOT EXECUTED
4000437c:	f0 24 a0 70 	st  %i0, [ %l2 + 0x70 ]                        <== NOT EXECUTED
    rtems_device_minor_number new_size = 0;                           
                                                                      
    if (old_size == 0) {                                              
      new_size = DISKTAB_INITIAL_SIZE;                                
    } else {                                                          
      new_size = 2 * old_size;                                        
40004380:	a5 2e 20 01 	sll  %i0, 1, %l2                               
    }                                                                 
    if (minor >= new_size) {                                          
40004384:	80 a6 40 12 	cmp  %i1, %l2                                  
40004388:	0a bf ff d9 	bcs  400042ec <create_disk+0x88>               <== ALWAYS TAKEN
4000438c:	90 10 00 1d 	mov  %i5, %o0                                  
40004390:	10 bf ff d7 	b  400042ec <create_disk+0x88>                 <== NOT EXECUTED
40004394:	a4 06 60 01 	add  %i1, 1, %l2                               <== NOT EXECUTED
                                                                      
  if (*dd_entry != NULL) {                                            
    return RTEMS_RESOURCE_IN_USE;                                     
  }                                                                   
                                                                      
  dd = malloc(sizeof(*dd));                                           
40004398:	40 00 05 35 	call  4000586c <malloc>                        
4000439c:	90 10 20 78 	mov  0x78, %o0                                 
  if (dd == NULL) {                                                   
400043a0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400043a4:	02 bf ff e2 	be  4000432c <create_disk+0xc8>                <== NEVER TAKEN
400043a8:	80 a6 a0 00 	cmp  %i2, 0                                    
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
400043ac:	02 80 00 0f 	be  400043e8 <create_disk+0x184>               
400043b0:	b0 10 20 00 	clr  %i0                                       
    alloc_name = strdup(name);                                        
400043b4:	40 00 46 fd 	call  40015fa8 <strdup>                        
400043b8:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    if (alloc_name == NULL) {                                         
400043bc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400043c0:	02 80 00 16 	be  40004418 <create_disk+0x1b4>               <== NEVER TAKEN
400043c4:	b4 10 00 08 	mov  %o0, %i2                                  
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {                 
400043c8:	94 10 00 11 	mov  %l1, %o2                                  
400043cc:	13 00 00 18 	sethi  %hi(0x6000), %o1                        
400043d0:	96 10 00 19 	mov  %i1, %o3                                  
400043d4:	40 00 05 95 	call  40005a28 <mknod>                         
400043d8:	92 12 61 ff 	or  %o1, 0x1ff, %o1                            
400043dc:	80 a2 20 00 	cmp  %o0, 0                                    
400043e0:	06 80 00 07 	bl  400043fc <create_disk+0x198>               <== NEVER TAKEN
400043e4:	01 00 00 00 	nop                                            
      free(dd);                                                       
      return RTEMS_UNSATISFIED;                                       
    }                                                                 
  }                                                                   
                                                                      
  *dd_entry = dd;                                                     
400043e8:	fa 24 00 00 	st  %i5, [ %l0 ]                               
  *dd_ptr = dd;                                                       
400043ec:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
  *alloc_name_ptr = alloc_name;                                       
400043f0:	f0 27 00 00 	st  %i0, [ %i4 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
400043f4:	81 c7 e0 08 	ret                                            
400043f8:	91 e8 20 00 	restore  %g0, 0, %o0                           
    }                                                                 
  }                                                                   
                                                                      
  if (name != NULL) {                                                 
    if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {                 
      free(alloc_name);                                               
400043fc:	40 00 03 d4 	call  4000534c <free>                          <== NOT EXECUTED
40004400:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
      free(dd);                                                       
40004404:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40004408:	40 00 03 d1 	call  4000534c <free>                          <== NOT EXECUTED
4000440c:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
      return RTEMS_UNSATISFIED;                                       
40004410:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004414:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  if (name != NULL) {                                                 
    alloc_name = strdup(name);                                        
                                                                      
    if (alloc_name == NULL) {                                         
      free(dd);                                                       
40004418:	40 00 03 cd 	call  4000534c <free>                          <== NOT EXECUTED
4000441c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40004420:	30 bf ff c3 	b,a   4000432c <create_disk+0xc8>              <== NOT EXECUTED
                                                                      

40005720 <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)
40005720:	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)   
40005724:	90 10 20 01 	mov  1, %o0                                    
    if (new_part_desc == NULL)                                        
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    *new_part_desc = NULL;                                            
40005728:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
    if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)   
4000572c:	40 00 03 54 	call  4000647c <calloc>                        
40005730:	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)   
40005734:	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)   
40005738:	ba 10 00 08 	mov  %o0, %i5                                  
4000573c:	80 a2 20 00 	cmp  %o0, 0                                    
40005740:	02 80 00 40 	be  40005840 <data_to_part_desc.part.1+0x120>  <== NEVER TAKEN
40005744:	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));
40005748:	c6 08 60 0b 	ldub  [ %g1 + 0xb ], %g3                       
4000574c:	da 08 60 08 	ldub  [ %g1 + 8 ], %o5                         
40005750:	de 08 60 09 	ldub  [ %g1 + 9 ], %o7                         
40005754:	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));
40005758:	f6 08 60 0d 	ldub  [ %g1 + 0xd ], %i3                       
4000575c:	f8 08 60 0e 	ldub  [ %g1 + 0xe ], %i4                       
40005760:	c8 08 60 0f 	ldub  [ %g1 + 0xf ], %g4                       
40005764:	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));
40005768:	c6 2f bf ff 	stb  %g3, [ %fp + -1 ]                         
4000576c:	da 2f bf fc 	stb  %o5, [ %fp + -4 ]                         
40005770:	de 2f bf fd 	stb  %o7, [ %fp + -3 ]                         
40005774:	f0 2f bf fe 	stb  %i0, [ %fp + -2 ]                         
    part_desc->start = LE_TO_CPU_U32(temp);                           
40005778:	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);
4000577c:	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);
40005780:	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));
40005784:	f6 2f bf fd 	stb  %i3, [ %fp + -3 ]                         
40005788:	f8 2f bf fe 	stb  %i4, [ %fp + -2 ]                         
4000578c:	c8 2f bf ff 	stb  %g4, [ %fp + -1 ]                         
40005790:	f4 2f bf fc 	stb  %i2, [ %fp + -4 ]                         
    part_desc->size = LE_TO_CPU_U32(temp);                            
40005794:	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;     
40005798:	b7 28 a0 18 	sll  %g2, 0x18, %i3                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
4000579c:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
400057a0:	b9 30 a0 08 	srl  %g2, 8, %i4                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400057a4:	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;                                       
400057a8:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400057ac:	b9 2f 20 10 	sll  %i4, 0x10, %i4                            
400057b0:	88 11 00 1c 	or  %g4, %i4, %g4                              
400057b4:	b7 28 60 18 	sll  %g1, 0x18, %i3                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
400057b8:	b9 30 60 18 	srl  %g1, 0x18, %i4                            
  byte3 = (value >> 16) & 0xff;                                       
400057bc:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400057c0:	b8 16 c0 1c 	or  %i3, %i4, %i4                              
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
400057c4:	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);
400057c8:	c6 2a 00 00 	stb  %g3, [ %o0 ]                              
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400057cc:	85 28 a0 08 	sll  %g2, 8, %g2                               
    part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
400057d0:	d2 2a 20 01 	stb  %o1, [ %o0 + 1 ]                          
400057d4:	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;                                       
400057d8:	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);                           
400057dc:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
400057e0:	88 09 20 ff 	and  %g4, 0xff, %g4                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
400057e4:	83 30 60 10 	srl  %g1, 0x10, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400057e8:	89 29 20 10 	sll  %g4, 0x10, %g4                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
400057ec:	82 08 60 ff 	and  %g1, 0xff, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400057f0:	b8 17 00 04 	or  %i4, %g4, %i4                              
400057f4:	83 28 60 08 	sll  %g1, 8, %g1                               
400057f8:	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) ||                           
400057fc:	82 0a 60 7f 	and  %o1, 0x7f, %g1                            
40005800:	80 a0 60 05 	cmp  %g1, 5                                    
40005804:	02 80 00 11 	be  40005848 <data_to_part_desc.part.1+0x128>  
40005808:	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)));
4000580c:	92 0a 60 ff 	and  %o1, 0xff, %o1                            
40005810:	11 10 00 99 	sethi  %hi(0x40026400), %o0                    
40005814:	94 10 20 06 	mov  6, %o2                                    
40005818:	40 00 45 60 	call  40016d98 <memchr>                        
4000581c:	90 12 22 d0 	or  %o0, 0x2d0, %o0                            
     * use partitions that are                                        
     * - extended                                                     
     * or                                                             
     * - FAT type and non-zero                                        
     */                                                               
    if (is_extended(part_desc->sys_type) ||                           
40005820:	80 a2 20 00 	cmp  %o0, 0                                    
40005824:	02 80 00 04 	be  40005834 <data_to_part_desc.part.1+0x114>  
40005828:	80 a7 20 00 	cmp  %i4, 0                                    
       ((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
4000582c:	32 80 00 08 	bne,a   4000584c <data_to_part_desc.part.1+0x12c><== ALWAYS TAKEN
40005830:	fa 26 40 00 	st  %i5, [ %i1 ]                               
      *new_part_desc = part_desc;                                     
    }                                                                 
    else {                                                            
      /* empty partition */                                           
      free(part_desc);                                                
40005834:	90 10 00 1d 	mov  %i5, %o0                                  
40005838:	40 00 03 48 	call  40006558 <free>                          
4000583c:	b0 10 20 00 	clr  %i0                                       
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40005840:	81 c7 e0 08 	ret                                            
40005844:	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;                                     
40005848:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    }                                                                 
    else {                                                            
      /* empty partition */                                           
      free(part_desc);                                                
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
4000584c:	81 c7 e0 08 	ret                                            
40005850:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40003640 <devFS_Show>: #endif #include "devfs.h" void devFS_Show(void) {
40003640:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
40003644:	03 10 00 51 	sethi  %hi(0x40014400), %g1                    
40003648:	c2 00 62 4c 	ld  [ %g1 + 0x24c ], %g1	! 4001464c <rtems_current_user_env>
                                                                      
  if (rootloc->mt_entry->ops == &devFS_ops) {                         
4000364c:	05 10 00 4e 	sethi  %hi(0x40013800), %g2                    
40003650:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40003654:	84 10 a0 d4 	or  %g2, 0xd4, %g2                             
40003658:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
4000365c:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
40003660:	80 a0 c0 02 	cmp  %g3, %g2                                  
40003664:	22 80 00 04 	be,a   40003674 <devFS_Show+0x34>              <== ALWAYS TAKEN
40003668:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
4000366c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003670:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    const devFS_data *data = devFS_get_data(rootloc);                 
    size_t i = 0;                                                     
    size_t n = data->count;                                           
40003674:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
    devFS_node *nodes = data->nodes;                                  
                                                                      
    for (i = 0; i < n; ++i) {                                         
40003678:	80 a6 20 00 	cmp  %i0, 0                                    
4000367c:	02 bf ff fc 	be  4000366c <devFS_Show+0x2c>                 <== NEVER TAKEN
40003680:	f8 00 40 00 	ld  [ %g1 ], %i4                               
                                                                      
      if (current->name != NULL) {                                    
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
                                                                      
        printk("/");                                                  
40003684:	23 10 00 4e 	sethi  %hi(0x40013800), %l1                    
        for (j = 0; j < m; ++j) {                                     
          printk("%c", current->name [j]);                            
40003688:	35 10 00 4e 	sethi  %hi(0x40013800), %i2                    
        }                                                             
        printk(                                                       
4000368c:	21 10 00 4e 	sethi  %hi(0x40013800), %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) {                                         
40003690:	b2 10 20 00 	clr  %i1                                       
                                                                      
      if (current->name != NULL) {                                    
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
                                                                      
        printk("/");                                                  
40003694:	a2 14 61 28 	or  %l1, 0x128, %l1                            
        for (j = 0; j < m; ++j) {                                     
          printk("%c", current->name [j]);                            
40003698:	b4 16 a1 40 	or  %i2, 0x140, %i2                            
        }                                                             
        printk(                                                       
4000369c:	a0 14 21 30 	or  %l0, 0x130, %l0                            
    devFS_node *nodes = data->nodes;                                  
                                                                      
    for (i = 0; i < n; ++i) {                                         
      devFS_node *current = nodes + i;                                
                                                                      
      if (current->name != NULL) {                                    
400036a0:	c2 07 00 00 	ld  [ %i4 ], %g1                               
400036a4:	80 a0 60 00 	cmp  %g1, 0                                    
400036a8:	22 80 00 15 	be,a   400036fc <devFS_Show+0xbc>              
400036ac:	b2 06 60 01 	inc  %i1                                       
        size_t j = 0;                                                 
        size_t m = current->namelen;                                  
400036b0:	f6 07 20 04 	ld  [ %i4 + 4 ], %i3                           
                                                                      
        printk("/");                                                  
400036b4:	40 00 03 e8 	call  40004654 <printk>                        
400036b8:	90 10 00 11 	mov  %l1, %o0                                  
        for (j = 0; j < m; ++j) {                                     
400036bc:	80 a6 e0 00 	cmp  %i3, 0                                    
400036c0:	02 80 00 0a 	be  400036e8 <devFS_Show+0xa8>                 <== NEVER TAKEN
400036c4:	ba 10 20 00 	clr  %i5                                       
          printk("%c", current->name [j]);                            
400036c8:	c2 07 00 00 	ld  [ %i4 ], %g1                               
400036cc:	90 10 00 1a 	mov  %i2, %o0                                  
400036d0:	d2 48 40 1d 	ldsb  [ %g1 + %i5 ], %o1                       
400036d4:	40 00 03 e0 	call  40004654 <printk>                        
400036d8:	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) {                                     
400036dc:	80 a7 40 1b 	cmp  %i5, %i3                                  
400036e0:	32 bf ff fb 	bne,a   400036cc <devFS_Show+0x8c>             
400036e4:	c2 07 00 00 	ld  [ %i4 ], %g1                               
          printk("%c", current->name [j]);                            
        }                                                             
        printk(                                                       
400036e8:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
400036ec:	d4 07 20 0c 	ld  [ %i4 + 0xc ], %o2                         
400036f0:	40 00 03 d9 	call  40004654 <printk>                        
400036f4:	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) {                                         
400036f8:	b2 06 60 01 	inc  %i1                                       
400036fc:	80 a6 40 18 	cmp  %i1, %i0                                  
40003700:	12 bf ff e8 	bne  400036a0 <devFS_Show+0x60>                
40003704:	b8 07 20 14 	add  %i4, 0x14, %i4                            
40003708:	81 c7 e0 08 	ret                                            
4000370c:	81 e8 00 00 	restore                                        
                                                                      

4000dc40 <devFS_eval_path>: } void devFS_eval_path( rtems_filesystem_eval_path_context_t *ctx ) {
4000dc40:	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;       
4000dc44:	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;                                                   
4000dc48:	e2 06 00 00 	ld  [ %i0 ], %l1                               
4000dc4c:	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;                                                
4000dc50:	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;                                             
4000dc54:	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) {    
4000dc58:	80 a4 20 00 	cmp  %l0, 0                                    
4000dc5c:	02 80 00 3d 	be  4000dd50 <devFS_eval_path+0x110>           
4000dc60:	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;                                            
4000dc64:	b4 10 20 00 	clr  %i2                                       
  devFS_node *free_node = NULL;                                       
4000dc68:	82 10 20 00 	clr  %g1                                       
                                                                      
  for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {    
4000dc6c:	10 80 00 09 	b  4000dc90 <devFS_eval_path+0x50>             
4000dc70:	b8 10 20 00 	clr  %i4                                       
4000dc74:	80 a6 a0 00 	cmp  %i2, 0                                    
4000dc78:	12 80 00 18 	bne  4000dcd8 <devFS_eval_path+0x98>           <== NEVER TAKEN
4000dc7c:	b8 07 20 01 	inc  %i4                                       
4000dc80:	ba 07 60 14 	add  %i5, 0x14, %i5                            
4000dc84:	80 a7 00 10 	cmp  %i4, %l0                                  
4000dc88:	02 80 00 1f 	be  4000dd04 <devFS_eval_path+0xc4>            
4000dc8c:	82 10 00 1b 	mov  %i3, %g1                                  
    devFS_node *current = nodes + i;                                  
                                                                      
    if (current->name != NULL) {                                      
4000dc90:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000dc94:	80 a2 20 00 	cmp  %o0, 0                                    
4000dc98:	02 bf ff f7 	be  4000dc74 <devFS_eval_path+0x34>            
4000dc9c:	b6 10 00 1d 	mov  %i5, %i3                                  
      if (                                                            
4000dca0:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
4000dca4:	80 a6 40 02 	cmp  %i1, %g2                                  
4000dca8:	12 bf ff f3 	bne  4000dc74 <devFS_eval_path+0x34>           
4000dcac:	b6 10 00 01 	mov  %g1, %i3                                  
        current->namelen == pathlen                                   
          && memcmp(current->name, path, pathlen) == 0                
4000dcb0:	92 10 00 11 	mov  %l1, %o1                                  
4000dcb4:	40 00 0b 95 	call  40010b08 <memcmp>                        
4000dcb8:	94 10 00 19 	mov  %i1, %o2                                  
4000dcbc:	80 a2 20 00 	cmp  %o0, 0                                    
4000dcc0:	12 bf ff ee 	bne  4000dc78 <devFS_eval_path+0x38>           
4000dcc4:	80 a6 a0 00 	cmp  %i2, 0                                    
4000dcc8:	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) {    
4000dccc:	80 a6 a0 00 	cmp  %i2, 0                                    
4000dcd0:	02 bf ff ec 	be  4000dc80 <devFS_eval_path+0x40>            <== NEVER TAKEN
4000dcd4:	b8 07 20 01 	inc  %i4                                       
4000dcd8:	80 a6 e0 00 	cmp  %i3, 0                                    
4000dcdc:	22 bf ff ea 	be,a   4000dc84 <devFS_eval_path+0x44>         <== NEVER TAKEN
4000dce0:	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;                                                  
4000dce4:	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) {                     
4000dce8:	80 88 60 40 	btst  0x40, %g1                                
4000dcec:	12 80 00 15 	bne  4000dd40 <devFS_eval_path+0x100>          
4000dcf0:	01 00 00 00 	nop                                            
      currentloc->node_access = node;                                 
4000dcf4:	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;                                                   
4000dcf8:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
4000dcfc:	81 c7 e0 08 	ret                                            
4000dd00:	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) {                                                 
4000dd04:	80 a6 a0 00 	cmp  %i2, 0                                    
4000dd08:	12 bf ff f8 	bne  4000dce8 <devFS_eval_path+0xa8>           <== NEVER TAKEN
4000dd0c:	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) {                          
4000dd10:	80 88 60 20 	btst  0x20, %g1                                
4000dd14:	02 80 00 0d 	be  4000dd48 <devFS_eval_path+0x108>           <== NEVER TAKEN
4000dd18:	80 a6 e0 00 	cmp  %i3, 0                                    
      if (free_node != NULL) {                                        
4000dd1c:	02 80 00 11 	be  4000dd60 <devFS_eval_path+0x120>           <== NEVER TAKEN
4000dd20:	82 10 21 ff 	mov  0x1ff, %g1                                
        free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;                
4000dd24:	c2 26 e0 10 	st  %g1, [ %i3 + 0x10 ]                        
        currentloc->node_access = free_node;                          
4000dd28:	f6 26 20 20 	st  %i3, [ %i0 + 0x20 ]                        
  rtems_filesystem_eval_path_context_t *ctx,                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  ctx->token = token;                                                 
4000dd2c:	e2 26 20 08 	st  %l1, [ %i0 + 8 ]                           
  ctx->tokenlen = tokenlen;                                           
4000dd30:	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;                                                   
4000dd34:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
4000dd38:	81 c7 e0 08 	ret                                            
4000dd3c:	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);                  
4000dd40:	7f ff e1 ca 	call  40006468 <rtems_filesystem_eval_path_error>
4000dd44:	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);                  
4000dd48:	7f ff e1 c8 	call  40006468 <rtems_filesystem_eval_path_error><== NOT EXECUTED
4000dd4c:	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) {                          
4000dd50:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4000dd54:	80 88 60 20 	btst  0x20, %g1                                
4000dd58:	02 bf ff fc 	be  4000dd48 <devFS_eval_path+0x108>           <== NEVER TAKEN
4000dd5c:	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);                
4000dd60:	7f ff e1 c2 	call  40006468 <rtems_filesystem_eval_path_error>
4000dd64:	93 e8 20 1c 	restore  %g0, 0x1c, %o1                        
                                                                      

400051e4 <devFS_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
400051e4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
400051e8:	80 a6 a0 03 	cmp  %i2, 3                                    
400051ec:	22 80 00 18 	be,a   4000524c <devFS_mknod+0x68>             
400051f0:	c2 4e 40 00 	ldsb  [ %i1 ], %g1                             
    if (S_ISBLK(mode) || S_ISCHR(mode)) {                             
400051f4:	05 00 00 2c 	sethi  %hi(0xb000), %g2                        
400051f8:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
400051fc:	84 0e c0 02 	and  %i3, %g2, %g2                             
40005200:	80 a0 80 01 	cmp  %g2, %g1                                  
40005204:	12 80 00 23 	bne  40005290 <devFS_mknod+0xac>               
40005208:	01 00 00 00 	nop                                            
      char *dupname = malloc(namelen);                                
4000520c:	40 00 01 5a 	call  40005774 <malloc>                        
40005210:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
      if (dupname != NULL) {                                          
40005214:	84 92 20 00 	orcc  %o0, 0, %g2                              
40005218:	02 80 00 24 	be  400052a8 <devFS_mknod+0xc4>                
4000521c:	92 10 00 19 	mov  %i1, %o1                                  
        devFS_node *node = parentloc->node_access;                    
40005220:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
                                                                      
        node->name = dupname;                                         
40005224:	c4 20 40 00 	st  %g2, [ %g1 ]                               
        node->namelen = namelen;                                      
40005228:	f4 20 60 04 	st  %i2, [ %g1 + 4 ]                           
        node->major = rtems_filesystem_dev_major_t(dev);              
4000522c:	f8 20 60 08 	st  %i4, [ %g1 + 8 ]                           
        node->minor = rtems_filesystem_dev_minor_t(dev);              
40005230:	fa 20 60 0c 	st  %i5, [ %g1 + 0xc ]                         
        node->mode = mode;                                            
40005234:	f6 20 60 10 	st  %i3, [ %g1 + 0x10 ]                        
        memcpy(dupname, name, namelen);                               
40005238:	94 10 00 1a 	mov  %i2, %o2                                  
4000523c:	40 00 2e 5d 	call  40010bb0 <memcpy>                        
40005240:	b0 10 20 00 	clr  %i0                                       
40005244:	81 c7 e0 08 	ret                                            
40005248:	81 e8 00 00 	restore                                        
  dev_t dev                                                           
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
4000524c:	80 a0 60 64 	cmp  %g1, 0x64                                 
40005250:	12 bf ff ea 	bne  400051f8 <devFS_mknod+0x14>               <== NEVER TAKEN
40005254:	05 00 00 2c 	sethi  %hi(0xb000), %g2                        
40005258:	c2 4e 60 01 	ldsb  [ %i1 + 1 ], %g1                         
4000525c:	80 a0 60 65 	cmp  %g1, 0x65                                 
40005260:	12 bf ff e7 	bne  400051fc <devFS_mknod+0x18>               <== NEVER TAKEN
40005264:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
40005268:	c2 4e 60 02 	ldsb  [ %i1 + 2 ], %g1                         
4000526c:	80 a0 60 76 	cmp  %g1, 0x76                                 
40005270:	12 bf ff e3 	bne  400051fc <devFS_mknod+0x18>               <== NEVER TAKEN
40005274:	03 00 00 08 	sethi  %hi(0x2000), %g1                        
    } else {                                                          
      errno = ENOTSUP;                                                
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    if (!S_ISDIR(mode)) {                                             
40005278:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
4000527c:	b6 0e c0 01 	and  %i3, %g1, %i3                             
40005280:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
40005284:	80 a6 c0 01 	cmp  %i3, %g1                                  
40005288:	02 bf ff ef 	be  40005244 <devFS_mknod+0x60>                <== ALWAYS TAKEN
4000528c:	b0 10 20 00 	clr  %i0                                       
      errno = ENOTSUP;                                                
40005290:	40 00 2b af 	call  4001014c <__errno>                       
40005294:	b0 10 3f ff 	mov  -1, %i0                                   
40005298:	82 10 20 86 	mov  0x86, %g1                                 
4000529c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      rv = -1;                                                        
    }                                                                 
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400052a0:	81 c7 e0 08 	ret                                            
400052a4:	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;                                               
400052a8:	40 00 2b a9 	call  4001014c <__errno>                       
400052ac:	b0 10 3f ff 	mov  -1, %i0                                   
400052b0:	82 10 20 0c 	mov  0xc, %g1                                  
400052b4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400052b8:	81 c7 e0 08 	ret                                            
400052bc:	81 e8 00 00 	restore                                        
                                                                      

400041ec <disk_lock>: */ static volatile bool diskdevs_protected; static rtems_status_code disk_lock(void) {
400041ec:	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);
400041f0:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
400041f4:	d0 00 60 6c 	ld  [ %g1 + 0x6c ], %o0	! 4001c46c <diskdevs_mutex>
400041f8:	92 10 20 00 	clr  %o1                                       
400041fc:	94 10 20 00 	clr  %o2                                       
40004200:	40 00 15 f8 	call  400099e0 <rtems_semaphore_obtain>        
40004204:	b0 10 20 16 	mov  0x16, %i0                                 
  if (sc == RTEMS_SUCCESSFUL) {                                       
40004208:	80 a2 20 00 	cmp  %o0, 0                                    
4000420c:	12 80 00 05 	bne  40004220 <disk_lock+0x34>                 <== NEVER TAKEN
40004210:	84 10 20 01 	mov  1, %g2                                    
    diskdevs_protected = true;                                        
40004214:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
                                                                      
    return RTEMS_SUCCESSFUL;                                          
40004218:	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;                                        
4000421c:	c4 28 60 68 	stb  %g2, [ %g1 + 0x68 ]                       
                                                                      
    return RTEMS_SUCCESSFUL;                                          
  } else {                                                            
    return RTEMS_NOT_CONFIGURED;                                      
  }                                                                   
}                                                                     
40004220:	81 c7 e0 08 	ret                                            
40004224:	81 e8 00 00 	restore                                        
                                                                      

40004228 <disk_unlock>: static void disk_unlock(void) {
40004228:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  diskdevs_protected = false;                                         
                                                                      
  sc = rtems_semaphore_release(diskdevs_mutex);                       
4000422c:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
40004230:	d0 00 60 6c 	ld  [ %g1 + 0x6c ], %o0	! 4001c46c <diskdevs_mutex>
static void                                                           
disk_unlock(void)                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  diskdevs_protected = false;                                         
40004234:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
40004238:	c0 28 60 68 	clrb  [ %g1 + 0x68 ]	! 4001c468 <diskdevs_protected>
                                                                      
  sc = rtems_semaphore_release(diskdevs_mutex);                       
4000423c:	40 00 16 38 	call  40009b1c <rtems_semaphore_release>       
40004240:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004244:	80 a2 20 00 	cmp  %o0, 0                                    
40004248:	12 80 00 04 	bne  40004258 <disk_unlock+0x30>               <== NEVER TAKEN
4000424c:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
40004250:	81 c7 e0 08 	ret                                            
40004254:	81 e8 00 00 	restore                                        
    /* FIXME: Error number */                                         
    rtems_fatal_error_occurred(0xdeadbeef);                           
40004258:	40 00 17 9c 	call  4000a0c8 <rtems_fatal_error_occurred>    <== NOT EXECUTED
4000425c:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

40005dc8 <drainOutput.part.0>: /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty)
40005dc8:	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);                                  
40005dcc:	7f ff f1 c1 	call  400024d0 <sparc_disable_interrupts>      
40005dd0:	01 00 00 00 	nop                                            
    while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {              
40005dd4:	c4 06 20 84 	ld  [ %i0 + 0x84 ], %g2                        
40005dd8:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        
40005ddc:	80 a0 80 01 	cmp  %g2, %g1                                  
40005de0:	02 80 00 14 	be  40005e30 <drainOutput.part.0+0x68>         <== ALWAYS TAKEN
40005de4:	01 00 00 00 	nop                                            
      tty->rawOutBufState = rob_wait;                                 
40005de8:	b8 10 20 02 	mov  2, %i4	! 2 <PROM_START+0x2>               <== NOT EXECUTED
40005dec:	f8 26 20 94 	st  %i4, [ %i0 + 0x94 ]                        <== NOT EXECUTED
      rtems_interrupt_enable (level);                                 
40005df0:	7f ff f1 bc 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40005df4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      sc = rtems_semaphore_obtain(                                    
40005df8:	d0 06 20 8c 	ld  [ %i0 + 0x8c ], %o0                        <== NOT EXECUTED
40005dfc:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40005e00:	40 00 09 e3 	call  4000858c <rtems_semaphore_obtain>        <== NOT EXECUTED
40005e04:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
40005e08:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40005e0c:	12 80 00 0b 	bne  40005e38 <drainOutput.part.0+0x70>        <== NOT EXECUTED
40005e10:	01 00 00 00 	nop                                            <== NOT EXECUTED
        rtems_fatal_error_occurred (sc);                              
      rtems_interrupt_disable (level);                                
40005e14:	7f ff f1 af 	call  400024d0 <sparc_disable_interrupts>      <== NOT EXECUTED
40005e18:	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) {              
40005e1c:	c4 06 20 84 	ld  [ %i0 + 0x84 ], %g2                        <== NOT EXECUTED
40005e20:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
40005e24:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
40005e28:	32 bf ff f2 	bne,a   40005df0 <drainOutput.part.0+0x28>     <== NOT EXECUTED
40005e2c:	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);                                   
40005e30:	7f ff f1 ac 	call  400024e0 <sparc_enable_interrupts>       
40005e34:	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);                              
40005e38:	40 00 0b ba 	call  40008d20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
                                                                      

40004774 <dup>: int dup( int fildes ) { return fcntl( fildes, F_DUPFD, 0 );
40004774:	92 10 20 00 	clr  %o1                                       
40004778:	94 10 20 00 	clr  %o2                                       
4000477c:	82 13 c0 00 	mov  %o7, %g1                                  
40004780:	40 00 00 0c 	call  400047b0 <fcntl>                         
40004784:	9e 10 40 00 	mov  %g1, %o7                                  
40004788:	40 00 48 f0 	call  40016b48 <__umoddi3+0x36c>               <== NOT EXECUTED
4000478c:	40 00 48 e4 	call  40016b1c <__umoddi3+0x340>               <== NOT EXECUTED
40004790:	40 00 48 c4 	call  40016aa0 <__umoddi3+0x2c4>               <== NOT EXECUTED
40004794:	40 00 48 a4 	call  40016a24 <__umoddi3+0x248>               <== NOT EXECUTED
40004798:	40 00 48 50 	call  400168d8 <__umoddi3+0xfc>                <== NOT EXECUTED
4000479c:	40 00 48 38 	call  4001687c <__umoddi3+0xa0>                <== NOT EXECUTED
400047a0:	40 00 48 38 	call  40016880 <__umoddi3+0xa4>                <== NOT EXECUTED
400047a4:	40 00 48 38 	call  40016884 <__umoddi3+0xa8>                <== NOT EXECUTED
400047a8:	40 00 48 38 	call  40016888 <__umoddi3+0xac>                <== NOT EXECUTED
400047ac:	40 00 48 38 	call  4001688c <__umoddi3+0xb0>                <== NOT EXECUTED
                                                                      

40004728 <dup2>: */ int dup2( int fildes, int fildes2 ) {
40004728:	9d e3 bf 58 	save  %sp, -168, %sp                           
                                                                      
  /*                                                                  
   *  If fildes is not valid, then fildes2 should not be closed.      
   */                                                                 
                                                                      
  status = fstat( fildes, &buf );                                     
4000472c:	90 10 00 18 	mov  %i0, %o0                                  
40004730:	40 00 01 50 	call  40004c70 <fstat>                         
40004734:	92 07 bf b8 	add  %fp, -72, %o1                             
  if ( status == -1 )                                                 
40004738:	80 a2 3f ff 	cmp  %o0, -1                                   
4000473c:	02 80 00 0c 	be  4000476c <dup2+0x44>                       
40004740:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  /*                                                                  
   *  If fildes2 is not valid, then we should not do anything either. 
   */                                                                 
                                                                      
  status = fstat( fildes2, &buf );                                    
40004744:	40 00 01 4b 	call  40004c70 <fstat>                         
40004748:	92 07 bf b8 	add  %fp, -72, %o1                             
  if ( status == -1 )                                                 
4000474c:	80 a2 3f ff 	cmp  %o0, -1                                   
40004750:	02 80 00 07 	be  4000476c <dup2+0x44>                       <== NEVER TAKEN
40004754:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   *  This fcntl handles everything else.                             
   */                                                                 
                                                                      
  return fcntl( fildes, F_DUPFD, fildes2 );                           
40004758:	92 10 20 00 	clr  %o1                                       
4000475c:	40 00 00 15 	call  400047b0 <fcntl>                         
40004760:	94 10 00 19 	mov  %i1, %o2                                  
}                                                                     
40004764:	81 c7 e0 08 	ret                                            
40004768:	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;                                                        
4000476c:	81 c7 e0 08 	ret                                            
40004770:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

40006bec <echo>: /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) {
40006bec:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ((tty->termios.c_lflag & ECHOCTL) &&                             
40006bf0:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
40006bf4:	80 88 62 00 	btst  0x200, %g1                               
40006bf8:	02 80 00 0d 	be  40006c2c <echo+0x40>                       <== NEVER TAKEN
40006bfc:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
40006c00:	c2 00 63 60 	ld  [ %g1 + 0x360 ], %g1	! 4001f760 <__ctype_ptr__>
40006c04:	82 00 40 18 	add  %g1, %i0, %g1                             
40006c08:	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) &&                             
40006c0c:	80 88 60 20 	btst  0x20, %g1                                
40006c10:	02 80 00 08 	be  40006c30 <echo+0x44>                       
40006c14:	90 10 00 18 	mov  %i0, %o0                                  
       iscntrl(c) && (c != '\t') && (c != '\n')) {                    
40006c18:	82 06 3f f7 	add  %i0, -9, %g1                              
40006c1c:	82 08 60 ff 	and  %g1, 0xff, %g1                            
40006c20:	80 a0 60 01 	cmp  %g1, 1                                    
40006c24:	18 80 00 07 	bgu  40006c40 <echo+0x54>                      
40006c28:	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);                                                   
40006c2c:	90 10 00 18 	mov  %i0, %o0                                  
40006c30:	7f ff ff 8f 	call  40006a6c <oproc>                         
40006c34:	92 10 00 19 	mov  %i1, %o1                                  
40006c38:	81 c7 e0 08 	ret                                            
40006c3c:	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;                                            
40006c40:	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] = '^';                                                 
40006c44:	c2 2f bf f8 	stb  %g1, [ %fp + -8 ]                         
    echobuf[1] = c ^ 0x40;                                            
40006c48:	f0 2f bf f9 	stb  %i0, [ %fp + -7 ]                         
    rtems_termios_puts (echobuf, 2, tty);                             
40006c4c:	90 07 bf f8 	add  %fp, -8, %o0                              
40006c50:	92 10 20 02 	mov  2, %o1                                    
40006c54:	7f ff ff 36 	call  4000692c <rtems_termios_puts>            
40006c58:	94 10 00 19 	mov  %i1, %o2                                  
    tty->column += 2;                                                 
40006c5c:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        
40006c60:	82 00 60 02 	add  %g1, 2, %g1                               
40006c64:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        
40006c68:	81 c7 e0 08 	ret                                            
40006c6c:	81 e8 00 00 	restore                                        
                                                                      

40028928 <endgrent>: } void endgrent(void) { if (group_fp != NULL)
40028928:	03 10 01 a4 	sethi  %hi(0x40069000), %g1                    
4002892c:	d0 00 61 68 	ld  [ %g1 + 0x168 ], %o0	! 40069168 <group_fp> 
40028930:	80 a2 20 00 	cmp  %o0, 0                                    
40028934:	02 80 00 05 	be  40028948 <endgrent+0x20>                   <== NEVER TAKEN
40028938:	01 00 00 00 	nop                                            
    fclose(group_fp);                                                 
4002893c:	82 13 c0 00 	mov  %o7, %g1                                  
40028940:	40 00 4f dc 	call  4003c8b0 <fclose>                        
40028944:	9e 10 40 00 	mov  %g1, %o7                                  
40028948:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

4002878c <endpwent>: } void endpwent(void) { if (passwd_fp != NULL)
4002878c:	03 10 01 a4 	sethi  %hi(0x40069000), %g1                    
40028790:	d0 00 60 88 	ld  [ %g1 + 0x88 ], %o0	! 40069088 <passwd_fp> 
40028794:	80 a2 20 00 	cmp  %o0, 0                                    
40028798:	02 80 00 05 	be  400287ac <endpwent+0x20>                   <== NEVER TAKEN
4002879c:	01 00 00 00 	nop                                            
    fclose(passwd_fp);                                                
400287a0:	82 13 c0 00 	mov  %o7, %g1                                  
400287a4:	40 00 50 43 	call  4003c8b0 <fclose>                        
400287a8:	9e 10 40 00 	mov  %g1, %o7                                  
400287ac:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

40006c70 <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)
40006c70:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
          rtems_termios_puts ("\b", 1, tty);                          
40006c74:	37 10 00 78 	sethi  %hi(0x4001e000), %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)                   
40006c78:	ba 10 00 18 	mov  %i0, %i5                                  
          rtems_termios_puts ("\b", 1, tty);                          
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
40006c7c:	35 10 00 7d 	sethi  %hi(0x4001f400), %i2                    
          rtems_termios_puts ("\b \b", 3, tty);                       
40006c80:	31 10 00 78 	sethi  %hi(0x4001e000), %i0                    
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
          rtems_termios_puts ("\b", 1, tty);                          
40006c84:	b6 16 e1 50 	or  %i3, 0x150, %i3                            
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
          rtems_termios_puts ("\b \b", 3, tty);                       
40006c88:	10 80 00 0f 	b  40006cc4 <erase.part.2+0x54>                
40006c8c:	b0 16 21 58 	or  %i0, 0x158, %i0                            
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
        if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {       
          rtems_termios_puts ("\b \b", 3, tty);                       
40006c90:	90 12 21 58 	or  %o0, 0x158, %o0                            
40006c94:	92 10 20 03 	mov  3, %o1                                    
40006c98:	7f ff ff 25 	call  4000692c <rtems_termios_puts>            
40006c9c:	94 10 00 1d 	mov  %i5, %o2                                  
          if (tty->column)                                            
40006ca0:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40006ca4:	80 a0 60 00 	cmp  %g1, 0                                    
40006ca8:	02 80 00 05 	be  40006cbc <erase.part.2+0x4c>               <== NEVER TAKEN
40006cac:	80 a6 60 00 	cmp  %i1, 0                                    
            tty->column--;                                            
40006cb0:	82 00 7f ff 	add  %g1, -1, %g1                              
40006cb4:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
        }                                                             
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
40006cb8:	80 a6 60 00 	cmp  %i1, 0                                    
40006cbc:	02 80 00 58 	be  40006e1c <erase.part.2+0x1ac>              
40006cc0:	01 00 00 00 	nop                                            
        echo ('\n', tty);                                             
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
40006cc4:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40006cc8:	80 a0 a0 00 	cmp  %g2, 0                                    
40006ccc:	02 80 00 54 	be  40006e1c <erase.part.2+0x1ac>              
40006cd0:	84 00 bf ff 	add  %g2, -1, %g2                              
    unsigned char c = tty->cbuf[--tty->ccount];                       
40006cd4:	c8 07 60 1c 	ld  [ %i5 + 0x1c ], %g4                        
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
40006cd8:	c6 07 60 3c 	ld  [ %i5 + 0x3c ], %g3                        
      return;                                                         
    }                                                                 
  }                                                                   
                                                                      
  while (tty->ccount) {                                               
    unsigned char c = tty->cbuf[--tty->ccount];                       
40006cdc:	c4 27 60 20 	st  %g2, [ %i5 + 0x20 ]                        
                                                                      
    if (tty->termios.c_lflag & ECHO) {                                
40006ce0:	80 88 e0 08 	btst  8, %g3                                   
40006ce4:	02 bf ff f5 	be  40006cb8 <erase.part.2+0x48>               <== NEVER TAKEN
40006ce8:	c2 09 00 02 	ldub  [ %g4 + %g2 ], %g1                       
      if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {             
40006cec:	80 a6 60 00 	cmp  %i1, 0                                    
40006cf0:	12 80 00 05 	bne  40006d04 <erase.part.2+0x94>              
40006cf4:	82 08 60 ff 	and  %g1, 0xff, %g1                            
40006cf8:	80 88 e0 10 	btst  0x10, %g3                                
40006cfc:	22 80 00 4d 	be,a   40006e30 <erase.part.2+0x1c0>           <== NEVER TAKEN
40006d00:	f0 0f 60 43 	ldub  [ %i5 + 0x43 ], %i0                      <== NOT EXECUTED
        echo (tty->termios.c_cc[VERASE], tty);                        
      } else if (c == '\t') {                                         
40006d04:	80 a0 60 09 	cmp  %g1, 9                                    
40006d08:	02 80 00 1e 	be  40006d80 <erase.part.2+0x110>              
40006d0c:	80 a0 a0 00 	cmp  %g2, 0                                    
          rtems_termios_puts ("\b", 1, tty);                          
          tty->column--;                                              
        }                                                             
      }                                                               
      else {                                                          
        if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {        
40006d10:	c4 06 a3 60 	ld  [ %i2 + 0x360 ], %g2                       
40006d14:	b8 00 60 01 	add  %g1, 1, %i4                               
40006d18:	c2 08 80 1c 	ldub  [ %g2 + %i4 ], %g1                       
40006d1c:	80 88 60 20 	btst  0x20, %g1                                
40006d20:	02 bf ff dc 	be  40006c90 <erase.part.2+0x20>               <== ALWAYS TAKEN
40006d24:	11 10 00 78 	sethi  %hi(0x4001e000), %o0                    
40006d28:	80 88 e2 00 	btst  0x200, %g3                               <== NOT EXECUTED
40006d2c:	02 bf ff e4 	be  40006cbc <erase.part.2+0x4c>               <== NOT EXECUTED
40006d30:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
          rtems_termios_puts ("\b \b", 3, tty);                       
40006d34:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40006d38:	92 10 20 03 	mov  3, %o1                                    <== NOT EXECUTED
40006d3c:	7f ff fe fc 	call  4000692c <rtems_termios_puts>            <== NOT EXECUTED
40006d40:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
          if (tty->column)                                            
40006d44:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        <== NOT EXECUTED
40006d48:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40006d4c:	12 80 00 3b 	bne  40006e38 <erase.part.2+0x1c8>             <== NOT EXECUTED
40006d50:	11 10 00 78 	sethi  %hi(0x4001e000), %o0                    <== NOT EXECUTED
            tty->column--;                                            
        }                                                             
        if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {       
40006d54:	c2 06 a3 60 	ld  [ %i2 + 0x360 ], %g1                       <== NOT EXECUTED
40006d58:	c2 08 40 1c 	ldub  [ %g1 + %i4 ], %g1                       <== NOT EXECUTED
40006d5c:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
40006d60:	22 bf ff cd 	be,a   40006c94 <erase.part.2+0x24>            <== NOT EXECUTED
40006d64:	90 12 21 58 	or  %o0, 0x158, %o0                            <== NOT EXECUTED
40006d68:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
40006d6c:	80 88 62 00 	btst  0x200, %g1                               <== NOT EXECUTED
40006d70:	32 bf ff c9 	bne,a   40006c94 <erase.part.2+0x24>           <== NOT EXECUTED
40006d74:	90 12 21 58 	or  %o0, 0x158, %o0                            <== NOT EXECUTED
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
40006d78:	10 bf ff d1 	b  40006cbc <erase.part.2+0x4c>                <== NOT EXECUTED
40006d7c:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
40006d80:	02 80 00 17 	be  40006ddc <erase.part.2+0x16c>              
40006d84:	f8 07 60 2c 	ld  [ %i5 + 0x2c ], %i4                        
          c = tty->cbuf[i++];                                         
          if (c == '\t') {                                            
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
40006d88:	da 06 a3 60 	ld  [ %i2 + 0x360 ], %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;                                                    
40006d8c:	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)                       
40006d90:	10 80 00 07 	b  40006dac <erase.part.2+0x13c>               
40006d94:	98 08 e2 00 	and  %g3, 0x200, %o4                           
40006d98:	32 80 00 02 	bne,a   40006da0 <erase.part.2+0x130>          <== NOT EXECUTED
40006d9c:	b8 07 20 02 	add  %i4, 2, %i4                               <== NOT EXECUTED
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
40006da0:	80 a0 80 01 	cmp  %g2, %g1                                  
40006da4:	22 80 00 0f 	be,a   40006de0 <erase.part.2+0x170>           <== NEVER TAKEN
40006da8:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        <== NOT EXECUTED
          c = tty->cbuf[i++];                                         
40006dac:	c6 09 00 01 	ldub  [ %g4 + %g1 ], %g3                       
40006db0:	82 00 60 01 	inc  %g1                                       
          if (c == '\t') {                                            
40006db4:	80 a0 e0 09 	cmp  %g3, 9                                    
40006db8:	02 80 00 1b 	be  40006e24 <erase.part.2+0x1b4>              
40006dbc:	9e 03 40 03 	add  %o5, %g3, %o7                             
            col = (col | 7) + 1;                                      
          } else if (iscntrl (c)) {                                   
40006dc0:	de 0b e0 01 	ldub  [ %o7 + 1 ], %o7                         
40006dc4:	80 8b e0 20 	btst  0x20, %o7                                
40006dc8:	12 bf ff f4 	bne  40006d98 <erase.part.2+0x128>             <== NEVER TAKEN
40006dcc:	80 a3 20 00 	cmp  %o4, 0                                    
        int i = 0;                                                    
                                                                      
        /*                                                            
         * Find the character before the tab                          
         */                                                           
        while (i != tty->ccount) {                                    
40006dd0:	80 a0 80 01 	cmp  %g2, %g1                                  
40006dd4:	12 bf ff f6 	bne  40006dac <erase.part.2+0x13c>             
40006dd8:	b8 07 20 01 	inc  %i4                                       
        }                                                             
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
40006ddc:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40006de0:	80 a0 40 1c 	cmp  %g1, %i4                                  
40006de4:	04 bf ff b6 	ble  40006cbc <erase.part.2+0x4c>              <== NEVER TAKEN
40006de8:	80 a6 60 00 	cmp  %i1, 0                                    
          rtems_termios_puts ("\b", 1, tty);                          
40006dec:	90 10 00 1b 	mov  %i3, %o0                                  
40006df0:	92 10 20 01 	mov  1, %o1                                    
40006df4:	7f ff fe ce 	call  4000692c <rtems_termios_puts>            
40006df8:	94 10 00 1d 	mov  %i5, %o2                                  
          tty->column--;                                              
40006dfc:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40006e00:	82 00 7f ff 	add  %g1, -1, %g1                              
        }                                                             
                                                                      
        /*                                                            
         * Back up over the tab                                       
         */                                                           
        while (tty->column > col) {                                   
40006e04:	80 a0 40 1c 	cmp  %g1, %i4                                  
40006e08:	14 bf ff f9 	bg  40006dec <erase.part.2+0x17c>              
40006e0c:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
          if (tty->column)                                            
            tty->column--;                                            
        }                                                             
      }                                                               
    }                                                                 
    if (!lineFlag)                                                    
40006e10:	80 a6 60 00 	cmp  %i1, 0                                    
40006e14:	32 bf ff ad 	bne,a   40006cc8 <erase.part.2+0x58>           <== ALWAYS TAKEN
40006e18:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40006e1c:	81 c7 e0 08 	ret                                            
40006e20:	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;                                      
40006e24:	b8 17 20 07 	or  %i4, 7, %i4                                
40006e28:	10 bf ff de 	b  40006da0 <erase.part.2+0x130>               
40006e2c:	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);                        
40006e30:	7f ff ff 6f 	call  40006bec <echo>                          <== NOT EXECUTED
40006e34:	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--;                                            
40006e38:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
40006e3c:	10 bf ff c6 	b  40006d54 <erase.part.2+0xe4>                <== NOT EXECUTED
40006e40:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        <== NOT EXECUTED
                                                                      

400052dc <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 ) {
400052dc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  memset(ctx, 0, sizeof(*ctx));                                       
400052e0:	92 10 20 00 	clr  %o1                                       
400052e4:	90 10 00 18 	mov  %i0, %o0                                  
400052e8:	40 00 30 24 	call  40011378 <memset>                        
400052ec:	94 10 20 38 	mov  0x38, %o2                                 
                                                                      
  ctx->path = path;                                                   
400052f0:	f2 26 00 00 	st  %i1, [ %i0 ]                               
  ctx->pathlen = pathlen;                                             
400052f4:	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) {                                             
400052f8:	80 a6 a0 00 	cmp  %i2, 0                                    
400052fc:	02 80 00 21 	be  40005380 <eval_path_start+0xa4>            
40005300:	f6 26 20 10 	st  %i3, [ %i0 + 0x10 ]                        
    char c = ctx->path [0];                                           
40005304:	f6 0e 40 00 	ldub  [ %i1 ], %i3                             
                                                                      
    ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
40005308:	40 00 01 a3 	call  40005994 <rtems_filesystem_global_location_obtain>
4000530c:	90 10 00 1c 	mov  %i4, %o0                                  
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
40005310:	83 2e e0 18 	sll  %i3, 0x18, %g1                            
40005314:	83 38 60 18 	sra  %g1, 0x18, %g1                            
                                                                      
    if (rtems_filesystem_is_delimiter(c)) {                           
40005318:	80 a0 60 5c 	cmp  %g1, 0x5c                                 
4000531c:	12 80 00 32 	bne  400053e4 <eval_path_start+0x108>          <== ALWAYS TAKEN
40005320:	d0 26 20 30 	st  %o0, [ %i0 + 0x30 ]                        
      ++ctx->path;                                                    
40005324:	c4 06 00 00 	ld  [ %i0 ], %g2                               <== NOT EXECUTED
      --ctx->pathlen;                                                 
40005328:	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;                                                    
4000532c:	84 00 a0 01 	inc  %g2                                       
      --ctx->pathlen;                                                 
40005330:	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;                                                    
40005334:	c4 26 00 00 	st  %g2, [ %i0 ]                               
      --ctx->pathlen;                                                 
40005338:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
      ctx->startloc = rtems_filesystem_global_location_obtain(        
4000533c:	40 00 01 96 	call  40005994 <rtems_filesystem_global_location_obtain>
40005340:	90 06 20 30 	add  %i0, 0x30, %o0                            
40005344:	d0 26 20 34 	st  %o0, [ %i0 + 0x34 ]                        
40005348:	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;
4000534c:	d0 00 60 14 	ld  [ %g1 + 0x14 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40005350:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40005354:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40005358:	9f c0 40 00 	call  %g1                                      
4000535c:	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(                                    
40005360:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
40005364:	40 00 1f 19 	call  4000cfc8 <rtems_filesystem_location_clone>
40005368:	90 10 00 1d 	mov  %i5, %o0                                  
    &ctx->currentloc,                                                 
    &ctx->startloc->location                                          
  );                                                                  
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
4000536c:	90 10 00 18 	mov  %i0, %o0                                  
40005370:	7f ff ff be 	call  40005268 <rtems_filesystem_eval_path_continue>
40005374:	b0 10 00 1d 	mov  %i5, %i0                                  
                                                                      
  return &ctx->currentloc;                                            
}                                                                     
40005378:	81 c7 e0 08 	ret                                            
4000537c:	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;              
40005380:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  return rtems_filesystem_global_location_obtain( &global_loc );      
40005384:	40 00 01 84 	call  40005994 <rtems_filesystem_global_location_obtain>
40005388:	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;              
4000538c:	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();    
40005390:	d0 26 20 30 	st  %o0, [ %i0 + 0x30 ]                        
                                                                      
  return rtems_filesystem_global_location_obtain( &global_loc );      
40005394:	40 00 01 80 	call  40005994 <rtems_filesystem_global_location_obtain>
40005398:	90 07 bf fc 	add  %fp, -4, %o0                              
    ctx->startloc = rtems_filesystem_global_location_obtain_null();   
    errno = ENOENT;                                                   
4000539c:	40 00 2d 69 	call  40010940 <__errno>                       
400053a0:	d0 26 20 34 	st  %o0, [ %i0 + 0x34 ]                        
400053a4:	c2 06 20 34 	ld  [ %i0 + 0x34 ], %g1                        
400053a8:	84 10 20 02 	mov  2, %g2                                    
400053ac:	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;
400053b0:	d0 00 60 14 	ld  [ %g1 + 0x14 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
400053b4:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
400053b8:	c2 00 40 00 	ld  [ %g1 ], %g1                               
400053bc:	9f c0 40 00 	call  %g1                                      
400053c0:	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(                                    
400053c4:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
400053c8:	40 00 1f 00 	call  4000cfc8 <rtems_filesystem_location_clone>
400053cc:	90 10 00 1d 	mov  %i5, %o0                                  
    &ctx->currentloc,                                                 
    &ctx->startloc->location                                          
  );                                                                  
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
400053d0:	90 10 00 18 	mov  %i0, %o0                                  
400053d4:	7f ff ff a5 	call  40005268 <rtems_filesystem_eval_path_continue>
400053d8:	b0 10 00 1d 	mov  %i5, %i0                                  
                                                                      
  return &ctx->currentloc;                                            
}                                                                     
400053dc:	81 c7 e0 08 	ret                                            
400053e0:	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)) {                           
400053e4:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
400053e8:	22 bf ff d0 	be,a   40005328 <eval_path_start+0x4c>         
400053ec:	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(        
400053f0:	40 00 01 69 	call  40005994 <rtems_filesystem_global_location_obtain>
400053f4:	90 10 00 1d 	mov  %i5, %o0                                  
400053f8:	d0 26 20 34 	st  %o0, [ %i0 + 0x34 ]                        
400053fc:	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;
40005400:	d0 00 60 14 	ld  [ %g1 + 0x14 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40005404:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40005408:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000540c:	9f c0 40 00 	call  %g1                                      
40005410:	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(                                    
40005414:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        
40005418:	40 00 1e ec 	call  4000cfc8 <rtems_filesystem_location_clone>
4000541c:	90 10 00 1d 	mov  %i5, %o0                                  
    &ctx->currentloc,                                                 
    &ctx->startloc->location                                          
  );                                                                  
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
40005420:	90 10 00 18 	mov  %i0, %o0                                  
40005424:	7f ff ff 91 	call  40005268 <rtems_filesystem_eval_path_continue>
40005428:	b0 10 00 1d 	mov  %i5, %i0                                  
                                                                      
  return &ctx->currentloc;                                            
}                                                                     
4000542c:	81 c7 e0 08 	ret                                            
40005430:	81 e8 00 00 	restore                                        
                                                                      

40014620 <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) {
40014620:	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);
40014624:	c2 0e 20 02 	ldub  [ %i0 + 2 ], %g1                         
40014628:	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)
4001462c:	c6 0e 20 89 	ldub  [ %i0 + 0x89 ], %g3                      
40014630:	84 20 80 01 	sub  %g2, %g1, %g2                             
40014634:	80 a0 e0 00 	cmp  %g3, 0                                    
40014638:	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);
4001463c:	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 -                                                 
40014640:	84 26 40 02 	sub  %i1, %g2, %g2                             
40014644:	02 80 00 06 	be  4001465c <fat_buf_access+0x3c>             
40014648:	b9 28 80 01 	sll  %g2, %g1, %i4                             
4001464c:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
40014650:	80 a0 40 19 	cmp  %g1, %i1                                  
40014654:	22 80 00 12 	be,a   4001469c <fat_buf_access+0x7c>          
40014658:	c2 06 20 8c 	ld  [ %i0 + 0x8c ], %g1                        
    {                                                                 
        fat_buf_release(fs_info);                                     
4001465c:	7f ff ff 7a 	call  40014444 <fat_buf_release>               
40014660:	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);
40014664:	d0 06 20 64 	ld  [ %i0 + 0x64 ], %o0                        
40014668:	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)                              
4001466c:	80 a6 a0 01 	cmp  %i2, 1                                    
40014670:	02 80 00 10 	be  400146b0 <fat_buf_access+0x90>             
40014674:	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);
40014678:	7f ff f6 c9 	call  4001219c <rtems_bdbuf_get>               
4001467c:	01 00 00 00 	nop                                            
        if (sc != RTEMS_SUCCESSFUL)                                   
40014680:	80 a2 20 00 	cmp  %o0, 0                                    
40014684:	12 80 00 0f 	bne  400146c0 <fat_buf_access+0xa0>            <== NEVER TAKEN
40014688:	82 10 20 01 	mov  1, %g1                                    
            rtems_set_errno_and_return_minus_one(EIO);                
        fs_info->c.blk_num = sec_num;                                 
4001468c:	f2 26 20 84 	st  %i1, [ %i0 + 0x84 ]                        
        fs_info->c.modified = 0;                                      
40014690:	c0 2e 20 88 	clrb  [ %i0 + 0x88 ]                           
        fs_info->c.state = FAT_CACHE_ACTUAL;                          
40014694:	c2 2e 20 89 	stb  %g1, [ %i0 + 0x89 ]                       
    }                                                                 
    *sec_buf = &fs_info->c.buf->buffer[blk_ofs];                      
40014698:	c2 06 20 8c 	ld  [ %i0 + 0x8c ], %g1                        
4001469c:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
400146a0:	b8 00 40 1c 	add  %g1, %i4, %i4                             
400146a4:	f8 26 c0 00 	st  %i4, [ %i3 ]                               
    return RC_OK;                                                     
}                                                                     
400146a8:	81 c7 e0 08 	ret                                            
400146ac:	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);
400146b0:	7f ff f6 fb 	call  4001229c <rtems_bdbuf_read>              
400146b4:	01 00 00 00 	nop                                            
        else                                                          
            sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
        if (sc != RTEMS_SUCCESSFUL)                                   
400146b8:	10 bf ff f3 	b  40014684 <fat_buf_access+0x64>              
400146bc:	80 a2 20 00 	cmp  %o0, 0                                    
            rtems_set_errno_and_return_minus_one(EIO);                
400146c0:	40 00 23 b4 	call  4001d590 <__errno>                       <== NOT EXECUTED
400146c4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400146c8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
400146cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400146d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400146d4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40014444 <fat_buf_release>: return RC_OK; } int fat_buf_release(fat_fs_info_t *fs_info) {
40014444:	9d e3 bf 98 	save  %sp, -104, %sp                           
    rtems_status_code sc = RTEMS_SUCCESSFUL;                          
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY)                          
40014448:	c2 0e 20 89 	ldub  [ %i0 + 0x89 ], %g1                      
    return RC_OK;                                                     
}                                                                     
                                                                      
int                                                                   
fat_buf_release(fat_fs_info_t *fs_info)                               
{                                                                     
4001444c:	ba 10 00 18 	mov  %i0, %i5                                  
    rtems_status_code sc = RTEMS_SUCCESSFUL;                          
                                                                      
    if (fs_info->c.state == FAT_CACHE_EMPTY)                          
40014450:	80 a0 60 00 	cmp  %g1, 0                                    
40014454:	02 80 00 6b 	be  40014600 <fat_buf_release+0x1bc>           
40014458:	b0 10 20 00 	clr  %i0                                       
        return RC_OK;                                                 
                                                                      
    if (fs_info->c.modified)                                          
4001445c:	c2 0f 60 88 	ldub  [ %i5 + 0x88 ], %g1                      
40014460:	80 a0 60 00 	cmp  %g1, 0                                    
40014464:	02 80 00 47 	be  40014580 <fat_buf_release+0x13c>           
40014468:	01 00 00 00 	nop                                            
    {                                                                 
        uint32_t sec_num = fs_info->c.blk_num;                        
4001446c:	c2 07 60 84 	ld  [ %i5 + 0x84 ], %g1                        
        bool     sec_of_fat = ((sec_num >= fs_info->vol.fat_loc) &&   
40014470:	c4 17 60 18 	lduh  [ %i5 + 0x18 ], %g2                      
40014474:	80 a0 40 02 	cmp  %g1, %g2                                  
40014478:	0a 80 00 06 	bcs  40014490 <fat_buf_release+0x4c>           
4001447c:	b8 10 20 00 	clr  %i4                                       
40014480:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40014484:	80 a0 40 02 	cmp  %g1, %g2                                  
40014488:	2a 80 00 46 	bcs,a   400145a0 <fat_buf_release+0x15c>       
4001448c:	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);            
40014490:	7f ff f8 40 	call  40012590 <rtems_bdbuf_release_modified>  
40014494:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        
        if (sc != RTEMS_SUCCESSFUL)                                   
40014498:	80 a2 20 00 	cmp  %o0, 0                                    
4001449c:	12 80 00 5b 	bne  40014608 <fat_buf_release+0x1c4>          <== NEVER TAKEN
400144a0:	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)                       
400144a4:	02 80 00 3c 	be  40014594 <fat_buf_release+0x150>           
400144a8:	c0 2f 60 88 	clrb  [ %i5 + 0x88 ]                           
400144ac:	c2 0f 60 54 	ldub  [ %i5 + 0x54 ], %g1                      
400144b0:	80 a0 60 00 	cmp  %g1, 0                                    
400144b4:	32 80 00 39 	bne,a   40014598 <fat_buf_release+0x154>       <== NEVER TAKEN
400144b8:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           <== NOT EXECUTED
        {                                                             
            uint8_t i;                                                
                                                                      
            for (i = 1; i < fs_info->vol.fats; i++)                   
400144bc:	c2 0f 60 0d 	ldub  [ %i5 + 0xd ], %g1                       
400144c0:	80 a0 60 01 	cmp  %g1, 1                                    
400144c4:	08 80 00 34 	bleu  40014594 <fat_buf_release+0x150>         <== NEVER TAKEN
400144c8:	b6 10 20 01 	mov  1, %i3                                    
400144cc:	10 80 00 16 	b  40014524 <fat_buf_release+0xe0>             
400144d0:	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); 
400144d4:	7f ff f7 72 	call  4001229c <rtems_bdbuf_read>              
400144d8:	94 07 bf fc 	add  %fp, -4, %o2                              
                }                                                     
                if ( sc != RTEMS_SUCCESSFUL)                          
400144dc:	80 a2 20 00 	cmp  %o0, 0                                    
400144e0:	12 80 00 44 	bne  400145f0 <fat_buf_release+0x1ac>          <== NEVER TAKEN
400144e4:	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);
400144e8:	d2 07 60 90 	ld  [ %i5 + 0x90 ], %o1                        
400144ec:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
400144f0:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
400144f4:	40 00 26 cc 	call  4001e024 <memcpy>                        
400144f8:	90 02 00 1c 	add  %o0, %i4, %o0                             
                sc = rtems_bdbuf_release_modified(bd);                
400144fc:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
40014500:	7f ff f8 24 	call  40012590 <rtems_bdbuf_release_modified>  
40014504:	b6 06 e0 01 	inc  %i3                                       
                if ( sc != RTEMS_SUCCESSFUL)                          
40014508:	80 a2 20 00 	cmp  %o0, 0                                    
4001450c:	12 80 00 39 	bne  400145f0 <fat_buf_release+0x1ac>          <== NEVER TAKEN
40014510:	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++)                   
40014514:	c2 0f 60 0d 	ldub  [ %i5 + 0xd ], %g1                       
40014518:	80 a2 00 01 	cmp  %o0, %g1                                  
4001451c:	3a 80 00 1f 	bcc,a   40014598 <fat_buf_release+0x154>       <== ALWAYS TAKEN
40014520:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           
            {                                                         
                rtems_bdbuf_buffer *bd;                               
                                                                      
                sec_num = fs_info->c.blk_num + fs_info->vol.fat_length * i,
40014524:	7f ff b8 1a 	call  4000258c <.umul>                         
40014528:	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);
4001452c:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         
40014530:	c6 07 60 84 	ld  [ %i5 + 0x84 ], %g3                        
40014534:	c4 0f 60 0c 	ldub  [ %i5 + 0xc ], %g2                       
40014538:	90 02 00 03 	add  %o0, %g3, %o0                             
4001453c:	84 20 80 01 	sub  %g2, %g1, %g2                             
40014540:	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);
40014544:	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 -                                                 
40014548:	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);                                
4001454c:	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                                      
40014550:	80 a7 20 00 	cmp  %i4, 0                                    
40014554:	12 bf ff e0 	bne  400144d4 <fat_buf_release+0x90>           
40014558:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
                    && fs_info->vol.bps == fs_info->vol.bytes_per_block)
4001455c:	c4 17 40 00 	lduh  [ %i5 ], %g2                             
40014560:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
40014564:	80 a0 80 01 	cmp  %g2, %g1                                  
40014568:	12 bf ff db 	bne  400144d4 <fat_buf_release+0x90>           
4001456c:	01 00 00 00 	nop                                            
                {                                                     
                    sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &bd);  
40014570:	7f ff f7 0b 	call  4001219c <rtems_bdbuf_get>               
40014574:	94 07 bf fc 	add  %fp, -4, %o2                              
                }                                                     
                else                                                  
                {                                                     
                    sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &bd); 
                }                                                     
                if ( sc != RTEMS_SUCCESSFUL)                          
40014578:	10 bf ff da 	b  400144e0 <fat_buf_release+0x9c>             
4001457c:	80 a2 20 00 	cmp  %o0, 0                                    
            }                                                         
        }                                                             
    }                                                                 
    else                                                              
    {                                                                 
        sc = rtems_bdbuf_release(fs_info->c.buf);                     
40014580:	7f ff f7 cc 	call  400124b0 <rtems_bdbuf_release>           
40014584:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        
        if (sc != RTEMS_SUCCESSFUL)                                   
40014588:	80 a2 20 00 	cmp  %o0, 0                                    
4001458c:	12 80 00 1f 	bne  40014608 <fat_buf_release+0x1c4>          <== NEVER TAKEN
40014590:	01 00 00 00 	nop                                            
            rtems_set_errno_and_return_minus_one(EIO);                
    }                                                                 
    fs_info->c.state = FAT_CACHE_EMPTY;                               
40014594:	c0 2f 60 89 	clrb  [ %i5 + 0x89 ]                           
    return RC_OK;                                                     
40014598:	81 c7 e0 08 	ret                                            
4001459c:	91 e8 20 00 	restore  %g0, 0, %o0                           
    uint32_t                              ino                         
    )                                                                 
{                                                                     
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
400145a0:	c8 0f 60 02 	ldub  [ %i5 + 2 ], %g4                         
400145a4:	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)                       
400145a8:	80 a0 a0 00 	cmp  %g2, 0                                    
400145ac:	12 bf ff b9 	bne  40014490 <fat_buf_release+0x4c>           <== NEVER TAKEN
400145b0:	b8 10 20 01 	mov  1, %i4                                    
            memcpy(fs_info->sec_buf,                                  
                   fs_info->c.buf->buffer + blk_ofs,                  
400145b4:	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,                                  
400145b8:	d0 07 60 90 	ld  [ %i5 + 0x90 ], %o0                        
400145bc:	d2 00 a0 1c 	ld  [ %g2 + 0x1c ], %o1                        
400145c0:	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);
400145c4:	84 09 20 ff 	and  %g4, 0xff, %g2                            
400145c8:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
400145cc:	86 20 c0 02 	sub  %g3, %g2, %g3                             
400145d0:	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);
400145d4:	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 -                                                 
400145d8:	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);                                
400145dc:	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) &&   
400145e0:	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,                                  
400145e4:	40 00 26 90 	call  4001e024 <memcpy>                        
400145e8:	92 02 40 02 	add  %o1, %g2, %o1                             
400145ec:	30 bf ff a9 	b,a   40014490 <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);     
400145f0:	40 00 23 e8 	call  4001d590 <__errno>                       <== NOT EXECUTED
400145f4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400145f8:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
400145fc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40014600:	81 c7 e0 08 	ret                                            
40014604:	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);                
40014608:	40 00 23 e2 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001460c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014610:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40014614:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40014618:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001461c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40014808 <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) {
40014808:	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));
4001480c:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
40014810:	82 20 40 1a 	sub  %g1, %i2, %g1                             
40014814:	80 a6 c0 01 	cmp  %i3, %g1                                  
40014818:	38 80 00 02 	bgu,a   40014820 <fat_cluster_set+0x18>        <== NEVER TAKEN
4001481c:	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)) )
40014820:	80 a6 60 00 	cmp  %i1, 0                                    
40014824:	32 80 00 06 	bne,a   4001483c <fat_cluster_set+0x34>        <== ALWAYS TAKEN
40014828:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
4001482c:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       <== NOT EXECUTED
40014830:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
40014834:	12 80 00 50 	bne  40014974 <fat_cluster_set+0x16c>          <== NOT EXECUTED
40014838:	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);
4001483c:	e0 0e 20 02 	ldub  [ %i0 + 2 ], %l0                         
40014840:	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);
40014844:	c4 0e 20 08 	ldub  [ %i0 + 8 ], %g2                         
40014848:	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;                                         
4001484c:	b2 06 7f fe 	add  %i1, -2, %i1                              
40014850:	a1 30 c0 10 	srl  %g3, %l0, %l0                             
        blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
40014854:	84 20 80 01 	sub  %g2, %g1, %g2                             
40014858:	b3 2e 40 02 	sll  %i1, %g2, %i1                             
        blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
4001485c:	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;
40014860:	85 36 80 01 	srl  %i2, %g1, %g2                             
  uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
40014864:	83 28 80 01 	sll  %g2, %g1, %g1                             
  ssize_t             bytes_written    = 0;                           
40014868:	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);
4001486c:	b4 26 80 01 	sub  %i2, %g1, %i2                             
  ssize_t             bytes_written    = 0;                           
  ssize_t             ret;                                            
                                                                      
  cur_blk += blocks_in_offset;                                        
40014870:	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;                       
40014874:	82 10 20 00 	clr  %g1                                       
  ssize_t             bytes_written    = 0;                           
  ssize_t             ret;                                            
                                                                      
  cur_blk += blocks_in_offset;                                        
                                                                      
  while (   (RC_OK == rc)                                             
40014878:	80 a6 e0 00 	cmp  %i3, 0                                    
4001487c:	02 80 00 25 	be  40014910 <fat_cluster_set+0x108>           <== NEVER TAKEN
40014880:	a4 10 20 01 	mov  1, %l2                                    
40014884:	80 a0 60 00 	cmp  %g1, 0                                    
40014888:	32 80 00 39 	bne,a   4001496c <fat_cluster_set+0x164>       <== NEVER TAKEN
4001488c:	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));
40014890:	c4 16 20 0a 	lduh  [ %i0 + 0xa ], %g2                       
40014894:	82 20 80 1a 	sub  %g2, %i2, %g1                             
40014898:	80 a0 40 1b 	cmp  %g1, %i3                                  
4001489c:	08 80 00 03 	bleu  400148a8 <fat_cluster_set+0xa0>          <== ALWAYS TAKEN
400148a0:	ba 10 00 01 	mov  %g1, %i5                                  
400148a4:	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));
400148a8:	80 a7 40 01 	cmp  %i5, %g1                                  
400148ac:	08 80 00 03 	bleu  400148b8 <fat_cluster_set+0xb0>          <== ALWAYS TAKEN
400148b0:	b2 10 00 1d 	mov  %i5, %i1                                  
400148b4:	b2 10 00 01 	mov  %g1, %i1                                  <== NOT EXECUTED
    uint32_t                              ino                         
    )                                                                 
{                                                                     
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
400148b8:	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)                                           
400148bc:	80 a6 60 00 	cmp  %i1, 0                                    
400148c0:	02 80 00 24 	be  40014950 <fat_cluster_set+0x148>           <== NEVER TAKEN
400148c4:	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);
400148c8:	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);
400148cc:	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)           
400148d0:	80 a0 80 19 	cmp  %g2, %i1                                  
400148d4:	02 80 00 21 	be  40014958 <fat_cluster_set+0x150>           
400148d8:	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);
400148dc:	94 10 20 01 	mov  1, %o2                                    
400148e0:	7f ff ff 50 	call  40014620 <fat_buf_access>                
400148e4:	96 07 bf fc 	add  %fp, -4, %o3                              
                                                                      
        if (RC_OK == rc)                                              
400148e8:	80 a2 20 00 	cmp  %o0, 0                                    
400148ec:	22 80 00 14 	be,a   4001493c <fat_cluster_set+0x134>        <== ALWAYS TAKEN
400148f0:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
        fs_info,                                                      
        cur_blk,                                                      
        ofs_blk,                                                      
        c,                                                            
        pattern);                                                     
    if (c != ret)                                                     
400148f4:	80 a2 00 1d 	cmp  %o0, %i5                                  
400148f8:	02 80 00 0b 	be  40014924 <fat_cluster_set+0x11c>           <== ALWAYS TAKEN
400148fc:	82 10 3f ff 	mov  -1, %g1                                   
40014900:	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)                                             
40014904:	80 a6 e0 00 	cmp  %i3, 0                                    
40014908:	12 bf ff e0 	bne  40014888 <fat_cluster_set+0x80>           <== NEVER TAKEN
4001490c:	80 a0 60 00 	cmp  %g1, 0                                    
        bytes_written  += ret;                                        
        ++cur_blk;                                                    
    }                                                                 
    ofs_blk = 0;                                                      
  }                                                                   
  if (RC_OK != rc)                                                    
40014910:	80 a0 60 00 	cmp  %g1, 0                                    
40014914:	12 80 00 16 	bne  4001496c <fat_cluster_set+0x164>          <== NEVER TAKEN
40014918:	b0 10 3f ff 	mov  -1, %i0                                   
4001491c:	81 c7 e0 08 	ret                                            
40014920:	91 e8 00 11 	restore  %g0, %l1, %o0                         
        pattern);                                                     
    if (c != ret)                                                     
      rc = -1;                                                        
    else                                                              
    {                                                                 
        bytes_to_write -= ret;                                        
40014924:	b6 26 c0 08 	sub  %i3, %o0, %i3                             
        bytes_written  += ret;                                        
40014928:	a2 04 40 08 	add  %l1, %o0, %l1                             
        ++cur_blk;                                                    
4001492c:	a0 04 20 01 	inc  %l0                                       
40014930:	82 10 20 00 	clr  %g1                                       
40014934:	10 bf ff f4 	b  40014904 <fat_cluster_set+0xfc>             
40014938:	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);        
4001493c:	92 10 00 1c 	mov  %i4, %o1                                  
40014940:	90 02 00 1a 	add  %o0, %i2, %o0                             
40014944:	40 00 25 f5 	call  4001e118 <memset>                        
40014948:	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;                                       
4001494c:	e4 2e 20 88 	stb  %l2, [ %i0 + 0x88 ]                       
        }                                                             
    }                                                                 
    if (RC_OK != rc)                                                  
        return rc;                                                    
    else                                                              
        return bytes_to_write;                                        
40014950:	10 bf ff e9 	b  400148f4 <fat_cluster_set+0xec>             
40014954:	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);
40014958:	94 10 20 02 	mov  2, %o2                                    
4001495c:	7f ff ff 31 	call  40014620 <fat_buf_access>                
40014960:	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)                                              
40014964:	10 bf ff e2 	b  400148ec <fat_cluster_set+0xe4>             
40014968:	80 a2 20 00 	cmp  %o0, 0                                    
  }                                                                   
  if (RC_OK != rc)                                                    
    return rc;                                                        
  else                                                                
    return bytes_written;                                             
}                                                                     
4001496c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014970:	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);
40014974:	c4 0e 20 02 	ldub  [ %i0 + 2 ], %g2                         <== NOT EXECUTED
40014978:	e0 06 20 20 	ld  [ %i0 + 0x20 ], %l0                        <== NOT EXECUTED
4001497c:	84 20 40 02 	sub  %g1, %g2, %g2                             <== NOT EXECUTED
40014980:	10 bf ff b8 	b  40014860 <fat_cluster_set+0x58>             <== NOT EXECUTED
40014984:	a1 34 00 02 	srl  %l0, %g2, %l0                             <== NOT EXECUTED
                                                                      

40014988 <fat_cluster_write>: const uint32_t start_cln, const uint32_t offset, const uint32_t count, const void *buff, const bool overwrite_cluster) {
40014988:	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));
4001498c:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
40014990:	82 20 40 1a 	sub  %g1, %i2, %g1                             
40014994:	80 a6 c0 01 	cmp  %i3, %g1                                  
40014998:	38 80 00 02 	bgu,a   400149a0 <fat_cluster_write+0x18>      <== NEVER TAKEN
4001499c:	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)) )
400149a0:	80 a6 60 00 	cmp  %i1, 0                                    
400149a4:	32 80 00 06 	bne,a   400149bc <fat_cluster_write+0x34>      
400149a8:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
400149ac:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
400149b0:	80 88 60 03 	btst  3, %g1                                   
400149b4:	12 80 00 52 	bne  40014afc <fat_cluster_write+0x174>        <== ALWAYS TAKEN
400149b8:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       
400149bc:	e2 0e 20 02 	ldub  [ %i0 + 2 ], %l1                         
400149c0:	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);
400149c4:	c4 0e 20 08 	ldub  [ %i0 + 8 ], %g2                         
400149c8:	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;                                         
400149cc:	b2 06 7f fe 	add  %i1, -2, %i1                              
400149d0:	a3 30 c0 11 	srl  %g3, %l1, %l1                             
        blk = cln << (fs_info->vol.bpc_log2 - fs_info->vol.bytes_per_block_log2);
400149d4:	84 20 80 01 	sub  %g2, %g1, %g2                             
400149d8:	b3 2e 40 02 	sll  %i1, %g2, %i1                             
        blk += fat_sector_num_to_block_num(fs_info, fs_info->vol.data_fsec);
400149dc:	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);
400149e0:	85 36 80 01 	srl  %i2, %g1, %g2                             
    uint32_t            ofs_blk          = offset - (blocks_in_offset << fs_info->vol.bytes_per_block_log2);
400149e4:	83 28 80 01 	sll  %g2, %g1, %g1                             
    ssize_t             bytes_written    = 0;                         
400149e8:	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);
400149ec:	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;                                      
400149f0:	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;                     
400149f4:	82 10 20 00 	clr  %g1                                       
    ssize_t             ret;                                          
    uint32_t            c;                                            
                                                                      
    cur_blk += blocks_in_offset;                                      
                                                                      
    while (   (RC_OK == rc)                                           
400149f8:	80 a6 e0 00 	cmp  %i3, 0                                    
400149fc:	02 80 00 27 	be  40014a98 <fat_cluster_write+0x110>         <== NEVER TAKEN
40014a00:	a6 10 20 01 	mov  1, %l3                                    
40014a04:	80 a0 60 00 	cmp  %g1, 0                                    
40014a08:	32 80 00 3b 	bne,a   40014af4 <fat_cluster_write+0x16c>     <== NEVER TAKEN
40014a0c:	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));
40014a10:	c4 16 20 0a 	lduh  [ %i0 + 0xa ], %g2                       
40014a14:	82 20 80 1a 	sub  %g2, %i2, %g1                             
40014a18:	80 a0 40 1b 	cmp  %g1, %i3                                  
40014a1c:	08 80 00 03 	bleu  40014a28 <fat_cluster_write+0xa0>        
40014a20:	b2 10 00 01 	mov  %g1, %i1                                  
40014a24:	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));
40014a28:	80 a6 40 01 	cmp  %i1, %g1                                  
40014a2c:	08 80 00 03 	bleu  40014a38 <fat_cluster_write+0xb0>        <== ALWAYS TAKEN
40014a30:	a0 10 00 19 	mov  %i1, %l0                                  
40014a34:	a0 10 00 01 	mov  %g1, %l0                                  <== NOT EXECUTED
    uint32_t                              ino                         
    )                                                                 
{                                                                     
                                                                      
    return (ino >= fs_info->uino_base);                               
}                                                                     
40014a38:	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)                                           
40014a3c:	80 a4 20 00 	cmp  %l0, 0                                    
40014a40:	02 80 00 26 	be  40014ad8 <fat_cluster_write+0x150>         <== NEVER TAKEN
40014a44:	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);
40014a48:	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);
40014a4c:	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                                        
40014a50:	80 a7 60 00 	cmp  %i5, 0                                    
40014a54:	12 80 00 23 	bne  40014ae0 <fat_cluster_write+0x158>        
40014a58:	93 2c 40 09 	sll  %l1, %o1, %o1                             
            || (bytes_to_write == fs_info->vol.bytes_per_block))      
40014a5c:	80 a0 80 10 	cmp  %g2, %l0                                  
40014a60:	02 80 00 20 	be  40014ae0 <fat_cluster_write+0x158>         
40014a64:	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);
40014a68:	7f ff fe ee 	call  40014620 <fat_buf_access>                
40014a6c:	96 07 bf fc 	add  %fp, -4, %o3                              
                                                                      
        if (RC_OK == rc)                                              
40014a70:	80 a2 20 00 	cmp  %o0, 0                                    
40014a74:	22 80 00 14 	be,a   40014ac4 <fat_cluster_write+0x13c>      <== ALWAYS TAKEN
40014a78:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
          cur_blk,                                                    
          ofs_blk,                                                    
          c,                                                          
          &buffer[bytes_written],                                     
          overwrite_cluster);                                         
      if (c != ret)                                                   
40014a7c:	80 a2 00 19 	cmp  %o0, %i1                                  
40014a80:	02 80 00 0b 	be  40014aac <fat_cluster_write+0x124>         <== ALWAYS TAKEN
40014a84:	82 10 3f ff 	mov  -1, %g1                                   
40014a88:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
    ssize_t             ret;                                          
    uint32_t            c;                                            
                                                                      
    cur_blk += blocks_in_offset;                                      
                                                                      
    while (   (RC_OK == rc)                                           
40014a8c:	80 a6 e0 00 	cmp  %i3, 0                                    
40014a90:	12 bf ff de 	bne  40014a08 <fat_cluster_write+0x80>         <== NEVER TAKEN
40014a94:	80 a0 60 00 	cmp  %g1, 0                                    
          bytes_written  += ret;                                      
          ++cur_blk;                                                  
      }                                                               
      ofs_blk = 0;                                                    
    }                                                                 
    if (RC_OK != rc)                                                  
40014a98:	80 a0 60 00 	cmp  %g1, 0                                    
40014a9c:	12 80 00 16 	bne  40014af4 <fat_cluster_write+0x16c>        <== NEVER TAKEN
40014aa0:	b0 10 3f ff 	mov  -1, %i0                                   
40014aa4:	81 c7 e0 08 	ret                                            
40014aa8:	91 e8 00 12 	restore  %g0, %l2, %o0                         
          overwrite_cluster);                                         
      if (c != ret)                                                   
        rc = -1;                                                      
      else                                                            
      {                                                               
          bytes_to_write -= ret;                                      
40014aac:	b6 26 c0 08 	sub  %i3, %o0, %i3                             
          bytes_written  += ret;                                      
40014ab0:	a4 04 80 08 	add  %l2, %o0, %l2                             
          ++cur_blk;                                                  
40014ab4:	a2 04 60 01 	inc  %l1                                       
40014ab8:	82 10 20 00 	clr  %g1                                       
40014abc:	10 bf ff f4 	b  40014a8c <fat_cluster_write+0x104>          
40014ac0:	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);            
40014ac4:	92 07 00 12 	add  %i4, %l2, %o1                             
40014ac8:	90 02 00 1a 	add  %o0, %i2, %o0                             
40014acc:	40 00 25 56 	call  4001e024 <memcpy>                        
40014ad0:	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;                                       
40014ad4:	e6 2e 20 88 	stb  %l3, [ %i0 + 0x88 ]                       
        }                                                             
    }                                                                 
    if (RC_OK != rc)                                                  
        return rc;                                                    
    else                                                              
        return bytes_to_write;                                        
40014ad8:	10 bf ff e9 	b  40014a7c <fat_cluster_write+0xf4>           
40014adc:	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);
40014ae0:	94 10 20 02 	mov  2, %o2                                    
40014ae4:	7f ff fe cf 	call  40014620 <fat_buf_access>                
40014ae8:	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)                                              
40014aec:	10 bf ff e2 	b  40014a74 <fat_cluster_write+0xec>           
40014af0:	80 a2 20 00 	cmp  %o0, 0                                    
    }                                                                 
    if (RC_OK != rc)                                                  
      return rc;                                                      
    else                                                              
      return bytes_written;                                           
}                                                                     
40014af4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014af8:	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);
40014afc:	c4 0e 20 02 	ldub  [ %i0 + 2 ], %g2                         
40014b00:	e2 06 20 20 	ld  [ %i0 + 0x20 ], %l1                        
40014b04:	84 20 40 02 	sub  %g1, %g2, %g2                             
40014b08:	10 bf ff b6 	b  400149e0 <fat_cluster_write+0x58>           
40014b0c:	a3 34 40 02 	srl  %l1, %g2, %l1                             
                                                                      

40013c90 <fat_file_close>: int fat_file_close( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd ) {
40013c90:	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)                                        
40013c94:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
40013c98:	80 a0 60 01 	cmp  %g1, 1                                    
40013c9c:	08 80 00 06 	bleu  40013cb4 <fat_file_close+0x24>           
40013ca0:	82 00 7f ff 	add  %g1, -1, %g1                              
    {                                                                 
        fat_fd->links_num--;                                          
        return rc;                                                    
40013ca4:	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--;                                          
40013ca8:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
     * flush any modified "cached" buffer back to disk                
     */                                                               
    rc = fat_buf_release(fs_info);                                    
                                                                      
    return rc;                                                        
}                                                                     
40013cac:	81 c7 e0 08 	ret                                            
40013cb0:	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)                             
40013cb4:	c2 0e 60 30 	ldub  [ %i1 + 0x30 ], %g1                      
40013cb8:	80 88 60 01 	btst  1, %g1                                   
40013cbc:	22 80 00 15 	be,a   40013d10 <fat_file_close+0x80>          
40013cc0:	d2 06 60 0c 	ld  [ %i1 + 0xc ], %o1                         
    {                                                                 
        rc = fat_file_truncate(fs_info, fat_fd, 0);                   
40013cc4:	90 10 00 18 	mov  %i0, %o0                                  
40013cc8:	92 10 00 19 	mov  %i1, %o1                                  
40013ccc:	7f ff ff b0 	call  40013b8c <fat_file_truncate>             
40013cd0:	94 10 20 00 	clr  %o2                                       
        if ( rc != RC_OK )                                            
40013cd4:	80 a2 20 00 	cmp  %o0, 0                                    
40013cd8:	12 bf ff f5 	bne  40013cac <fat_file_close+0x1c>            <== NEVER TAKEN
40013cdc:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
40013ce0:	40 00 0f 88 	call  40017b00 <_Chain_Extract>                
40013ce4:	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) )                
40013ce8:	d2 06 60 0c 	ld  [ %i1 + 0xc ], %o1                         
40013cec:	40 00 06 7a 	call  400156d4 <fat_ino_is_unique>             
40013cf0:	90 10 00 18 	mov  %i0, %o0                                  
40013cf4:	80 8a 20 ff 	btst  0xff, %o0                                
40013cf8:	32 80 00 11 	bne,a   40013d3c <fat_file_close+0xac>         <== NEVER TAKEN
40013cfc:	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);                                             
40013d00:	7f ff c8 23 	call  40005d8c <free>                          
40013d04:	90 10 00 19 	mov  %i1, %o0                                  
        }                                                             
    }                                                                 
    /*                                                                
     * flush any modified "cached" buffer back to disk                
     */                                                               
    rc = fat_buf_release(fs_info);                                    
40013d08:	40 00 01 cf 	call  40014444 <fat_buf_release>               
40013d0c:	81 e8 00 00 	restore                                        
                                                                      
        free(fat_fd);                                                 
    }                                                                 
    else                                                              
    {                                                                 
        if (fat_ino_is_unique(fs_info, fat_fd->ino))                  
40013d10:	40 00 06 71 	call  400156d4 <fat_ino_is_unique>             
40013d14:	90 10 00 18 	mov  %i0, %o0                                  
40013d18:	80 8a 20 ff 	btst  0xff, %o0                                
40013d1c:	02 80 00 05 	be  40013d30 <fat_file_close+0xa0>             
40013d20:	01 00 00 00 	nop                                            
        {                                                             
            fat_fd->links_num = 0;                                    
40013d24:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
        }                                                             
    }                                                                 
    /*                                                                
     * flush any modified "cached" buffer back to disk                
     */                                                               
    rc = fat_buf_release(fs_info);                                    
40013d28:	40 00 01 c7 	call  40014444 <fat_buf_release>               
40013d2c:	81 e8 00 00 	restore                                        
40013d30:	40 00 0f 74 	call  40017b00 <_Chain_Extract>                
40013d34:	90 10 00 19 	mov  %i1, %o0                                  
40013d38:	30 bf ff f2 	b,a   40013d00 <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);                
40013d3c:	40 00 06 5b 	call  400156a8 <fat_free_unique_ino>           <== NOT EXECUTED
40013d40:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40013d44:	30 bf ff ef 	b,a   40013d00 <fat_file_close+0x70>           <== NOT EXECUTED
                                                                      

40013e1c <fat_file_extend>: fat_file_fd_t *fat_fd, bool zero_fill, uint32_t new_length, uint32_t *a_length ) {
40013e1c:	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;                                           
40013e20:	f6 27 00 00 	st  %i3, [ %i4 ]                               
                                                                      
    if (new_length <= fat_fd->fat_file_size)                          
40013e24:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
    uint32_t                              new_length,                 
    uint32_t                             *a_length                    
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       chain = 0;                                         
40013e28:	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;                                       
40013e2c:	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)                          
40013e30:	80 a6 c0 01 	cmp  %i3, %g1                                  
40013e34:	08 80 00 16 	bleu  40013e8c <fat_file_extend+0x70>          
40013e38:	ba 10 00 18 	mov  %i0, %i5                                  
        return RC_OK;                                                 
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
40013e3c:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
40013e40:	80 a0 a0 01 	cmp  %g2, 1                                    
40013e44:	22 80 00 56 	be,a   40013f9c <fat_file_extend+0x180>        
40013e48:	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))) &
40013e4c:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         
                   (fs_info->vol.bpc - 1);                            
                                                                      
    bytes2add = new_length - fat_fd->fat_file_size;                   
40013e50:	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))) &
40013e54:	84 04 3f ff 	add  %l0, -1, %g2                              
40013e58:	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 -                                
40013e5c:	a0 24 00 12 	sub  %l0, %l2, %l0                             
40013e60:	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)                                     
40013e64:	80 a4 00 03 	cmp  %l0, %g3                                  
40013e68:	1a 80 00 03 	bcc  40013e74 <fat_file_extend+0x58>           
40013e6c:	a2 10 20 00 	clr  %l1                                       
        bytes2add -= bytes_remain;                                    
40013e70:	a2 20 c0 10 	sub  %g3, %l0, %l1                             
    else                                                              
        bytes2add = 0;                                                
                                                                      
    if (zero_fill && bytes_remain > 0) {                              
40013e74:	80 a4 20 00 	cmp  %l0, 0                                    
40013e78:	12 80 00 3c 	bne  40013f68 <fat_file_extend+0x14c>          
40013e7c:	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)                                               
40013e80:	80 a4 60 00 	cmp  %l1, 0                                    
40013e84:	32 80 00 04 	bne,a   40013e94 <fat_file_extend+0x78>        
40013e88:	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;                                                 
40013e8c:	81 c7 e0 08 	ret                                            
40013e90:	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;         
40013e94:	a4 04 7f ff 	add  %l1, -1, %l2                              
                                                                      
    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,     
40013e98:	90 10 00 1d 	mov  %i5, %o0                                  
     * file ) - return                                                
     */                                                               
    if (bytes2add == 0)                                               
        return RC_OK;                                                 
                                                                      
    cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;         
40013e9c:	a5 34 80 01 	srl  %l2, %g1, %l2                             
                                                                      
    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,     
40013ea0:	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;         
40013ea4:	a4 04 a0 01 	inc  %l2                                       
                                                                      
    rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,     
40013ea8:	96 07 bf fc 	add  %fp, -4, %o3                              
40013eac:	94 10 00 12 	mov  %l2, %o2                                  
40013eb0:	98 07 bf f8 	add  %fp, -8, %o4                              
40013eb4:	40 00 1e 90 	call  4001b8f4 <fat_scan_fat_for_free_clusters>
40013eb8:	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)                                                  
40013ebc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40013ec0:	12 80 00 28 	bne  40013f60 <fat_file_extend+0x144>          <== NEVER TAKEN
40013ec4:	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))                      
40013ec8:	80 94 00 01 	orcc  %l0, %g1, %g0                            
40013ecc:	02 80 00 3b 	be  40013fb8 <fat_file_extend+0x19c>           <== NEVER TAKEN
40013ed0:	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)                                         
40013ed4:	02 80 00 09 	be  40013ef8 <fat_file_extend+0xdc>            <== ALWAYS TAKEN
40013ed8:	a4 24 80 01 	sub  %l2, %g1, %l2                             
    {                                                                 
        new_length -= bytes2add & (fs_info->vol.bpc - 1);             
40013edc:	c6 17 60 06 	lduh  [ %i5 + 6 ], %g3                         <== NOT EXECUTED
        new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2; 
40013ee0:	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);             
40013ee4:	86 00 ff ff 	add  %g3, -1, %g3                              <== NOT EXECUTED
40013ee8:	a2 0c 40 03 	and  %l1, %g3, %l1                             <== NOT EXECUTED
        new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2; 
40013eec:	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);             
40013ef0:	b6 26 c0 11 	sub  %i3, %l1, %i3                             <== NOT EXECUTED
        new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2; 
40013ef4:	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 )                                 
40013ef8:	d6 06 60 18 	ld  [ %i1 + 0x18 ], %o3                        
40013efc:	80 a2 e0 00 	cmp  %o3, 0                                    
40013f00:	32 80 00 43 	bne,a   4001400c <fat_file_extend+0x1f0>       
40013f04:	d2 06 60 3c 	ld  [ %i1 + 0x3c ], %o1                        
    {                                                                 
        fat_fd->map.disk_cln = fat_fd->cln = chain;                   
40013f08:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         
        fat_fd->map.file_cln = 0;                                     
40013f0c:	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;                   
40013f10:	c4 26 60 1c 	st  %g2, [ %i1 + 0x1c ]                        
40013f14:	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)                                               
40013f18:	80 a0 60 00 	cmp  %g1, 0                                    
40013f1c:	22 80 00 39 	be,a   40014000 <fat_file_extend+0x1e4>        <== NEVER TAKEN
40013f20:	f6 27 00 00 	st  %i3, [ %i4 ]                               <== NOT EXECUTED
    {                                                                 
        fat_fd->map.last_cln = last_cl;                               
40013f24:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
        if (fat_fd->fat_file_type == FAT_DIRECTORY)                   
40013f28:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
40013f2c:	80 a0 60 00 	cmp  %g1, 0                                    
40013f30:	12 80 00 33 	bne  40013ffc <fat_file_extend+0x1e0>          
40013f34:	c4 26 60 3c 	st  %g2, [ %i1 + 0x3c ]                        
        {                                                             
            rc = fat_init_clusters_chain(fs_info, chain);             
40013f38:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
40013f3c:	40 00 05 80 	call  4001553c <fat_init_clusters_chain>       
40013f40:	90 10 00 1d 	mov  %i5, %o0                                  
            if ( rc != RC_OK )                                        
40013f44:	82 92 20 00 	orcc  %o0, 0, %g1                              
40013f48:	22 80 00 2e 	be,a   40014000 <fat_file_extend+0x1e4>        <== ALWAYS TAKEN
40013f4c:	f6 27 00 00 	st  %i3, [ %i4 ]                               
            {                                                         
                fat_free_fat_clusters_chain(fs_info, chain);          
40013f50:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         <== NOT EXECUTED
40013f54:	b0 10 00 01 	mov  %g1, %i0                                  <== NOT EXECUTED
40013f58:	40 00 1e 2f 	call  4001b814 <fat_free_fat_clusters_chain>   <== NOT EXECUTED
40013f5c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40013f60:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013f64:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    if (bytes2add > bytes_remain)                                     
        bytes2add -= bytes_remain;                                    
    else                                                              
        bytes2add = 0;                                                
                                                                      
    if (zero_fill && bytes_remain > 0) {                              
40013f68:	02 bf ff c7 	be  40013e84 <fat_file_extend+0x68>            
40013f6c:	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;           
40013f70:	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);     
40013f74:	90 10 00 1d 	mov  %i5, %o0                                  
40013f78:	92 10 00 19 	mov  %i1, %o1                                  
40013f7c:	95 30 40 0a 	srl  %g1, %o2, %o2                             
40013f80:	7f ff fd 9b 	call  400135ec <fat_file_lseek>                
40013f84:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (rc != RC_OK)                                              
40013f88:	b0 92 60 00 	orcc  %o1, 0, %i0                              
40013f8c:	02 80 00 11 	be  40013fd0 <fat_file_extend+0x1b4>           <== ALWAYS TAKEN
40013f90:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
                                                                      
    *a_length = new_length;                                           
    fat_fd->fat_file_size = new_length;                               
                                                                      
    return RC_OK;                                                     
}                                                                     
40013f94:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013f98:	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)) &&                               
40013f9c:	80 a0 a0 00 	cmp  %g2, 0                                    
40013fa0:	32 bf ff ac 	bne,a   40013e50 <fat_file_extend+0x34>        <== NEVER TAKEN
40013fa4:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
40013fa8:	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)) &&                               
40013fac:	80 88 a0 03 	btst  3, %g2                                   
40013fb0:	22 bf ff a8 	be,a   40013e50 <fat_file_extend+0x34>         <== NEVER TAKEN
40013fb4:	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);                 
40013fb8:	40 00 25 76 	call  4001d590 <__errno>                       
40013fbc:	b0 10 3f ff 	mov  -1, %i0                                   
40013fc0:	82 10 20 1c 	mov  0x1c, %g1                                 
40013fc4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40013fc8:	81 c7 e0 08 	ret                                            
40013fcc:	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);
40013fd0:	90 10 00 1d 	mov  %i5, %o0                                  
40013fd4:	94 10 00 12 	mov  %l2, %o2                                  
40013fd8:	96 10 00 10 	mov  %l0, %o3                                  
40013fdc:	98 10 20 00 	clr  %o4                                       
40013fe0:	40 00 02 0a 	call  40014808 <fat_cluster_set>               
40013fe4:	b0 10 3f ff 	mov  -1, %i0                                   
        if (bytes_remain != bytes_written)                            
40013fe8:	80 a2 00 10 	cmp  %o0, %l0                                  
40013fec:	02 bf ff a6 	be  40013e84 <fat_file_extend+0x68>            <== ALWAYS TAKEN
40013ff0:	80 a4 60 00 	cmp  %l1, 0                                    
                                                                      
    *a_length = new_length;                                           
    fat_fd->fat_file_size = new_length;                               
                                                                      
    return RC_OK;                                                     
}                                                                     
40013ff4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013ff8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                return rc;                                            
            }                                                         
        }                                                             
    }                                                                 
                                                                      
    *a_length = new_length;                                           
40013ffc:	f6 27 00 00 	st  %i3, [ %i4 ]                               
    fat_fd->fat_file_size = new_length;                               
40014000:	f6 26 60 18 	st  %i3, [ %i1 + 0x18 ]                        
                                                                      
    return RC_OK;                                                     
}                                                                     
40014004:	81 c7 e0 08 	ret                                            
40014008:	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)              
4001400c:	80 a2 7f ff 	cmp  %o1, -1                                   
40014010:	22 80 00 0d 	be,a   40014044 <fat_file_extend+0x228>        <== NEVER TAKEN
40014014:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
        {                                                             
            old_last_cl = fat_fd->map.last_cln;                       
40014018:	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);        
4001401c:	d4 07 bf f0 	ld  [ %fp + -16 ], %o2                         
40014020:	40 00 1d 4b 	call  4001b54c <fat_set_fat_cluster>           
40014024:	90 10 00 1d 	mov  %i5, %o0                                  
        if ( rc != RC_OK )                                            
40014028:	82 92 20 00 	orcc  %o0, 0, %g1                              
4001402c:	12 bf ff ca 	bne  40013f54 <fat_file_extend+0x138>          <== NEVER TAKEN
40014030:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
        {                                                             
            fat_free_fat_clusters_chain(fs_info, chain);              
            return rc;                                                
        }                                                             
        fat_buf_release(fs_info);                                     
40014034:	40 00 01 04 	call  40014444 <fat_buf_release>               
40014038:	90 10 00 1d 	mov  %i5, %o0                                  
4001403c:	10 bf ff b7 	b  40013f18 <fat_file_extend+0xfc>             
40014040:	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,           
40014044:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40014048:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
4001404c:	96 02 ff ff 	add  %o3, -1, %o3                              <== NOT EXECUTED
40014050:	7f ff ff 3e 	call  40013d48 <fat_file_ioctl>                <== NOT EXECUTED
40014054:	98 07 bf f4 	add  %fp, -12, %o4                             <== NOT EXECUTED
40014058:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         <== NOT EXECUTED
                                (fat_fd->fat_file_size - 1), &old_last_cl);
            if ( rc != RC_OK )                                        
4001405c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40014060:	02 bf ff ef 	be  4001401c <fat_file_extend+0x200>           <== NOT EXECUTED
40014064:	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);          
40014068:	10 bf ff bb 	b  40013f54 <fat_file_extend+0x138>            <== NOT EXECUTED
4001406c:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         <== NOT EXECUTED
                                                                      

40013d48 <fat_file_ioctl>: fat_file_ioctl( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd, int cmd, ...) {
40013d48:	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);                                                
40013d4c:	82 07 a0 50 	add  %fp, 0x50, %g1                            
40013d50:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
40013d54:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40013d58:	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;                                       
40013d5c:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    uint32_t      *ret;                                               
    va_list        ap;                                                
                                                                      
    va_start(ap, cmd);                                                
                                                                      
    switch (cmd)                                                      
40013d60:	80 a6 a0 01 	cmp  %i2, 1                                    
40013d64:	02 80 00 08 	be  40013d84 <fat_file_ioctl+0x3c>             <== ALWAYS TAKEN
40013d68:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
            *ret = cur_cln;                                           
            break;                                                    
                                                                      
        default:                                                      
            errno = EINVAL;                                           
40013d6c:	40 00 26 09 	call  4001d590 <__errno>                       <== NOT EXECUTED
40013d70:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013d74:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40013d78:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
            rc = -1;                                                  
            break;                                                    
    }                                                                 
    va_end(ap);                                                       
    return rc;                                                        
}                                                                     
40013d7c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013d80:	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 ) {                     
40013d84:	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 *);                             
40013d88:	86 07 a0 58 	add  %fp, 0x58, %g3                            
40013d8c:	c6 27 bf fc 	st  %g3, [ %fp + -4 ]                          
                                                                      
            /* sanity check */                                        
            if ( pos >= fat_fd->fat_file_size ) {                     
40013d90:	80 a6 c0 02 	cmp  %i3, %g2                                  
40013d94:	1a 80 00 1c 	bcc  40013e04 <fat_file_ioctl+0xbc>            <== NEVER TAKEN
40013d98:	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)) &&                       
40013d9c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
40013da0:	80 a0 60 01 	cmp  %g1, 1                                    
40013da4:	22 80 00 0e 	be,a   40013ddc <fat_file_ioctl+0x94>          
40013da8:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
                *ret  = 0;                                            
                rc = RC_OK;                                           
                break;                                                
            }                                                         
                                                                      
            cl_start = pos >> fs_info->vol.bpc_log2;                  
40013dac:	d4 0e 20 08 	ldub  [ %i0 + 8 ], %o2                         
                                                                      
            rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln); 
40013db0:	90 10 00 18 	mov  %i0, %o0                                  
40013db4:	92 10 00 19 	mov  %i1, %o1                                  
40013db8:	95 36 c0 0a 	srl  %i3, %o2, %o2                             
40013dbc:	7f ff fe 0c 	call  400135ec <fat_file_lseek>                
40013dc0:	96 07 bf f8 	add  %fp, -8, %o3                              
            if ( rc != RC_OK )                                        
40013dc4:	b0 92 60 00 	orcc  %o1, 0, %i0                              
40013dc8:	12 bf ff ed 	bne  40013d7c <fat_file_ioctl+0x34>            <== NEVER TAKEN
40013dcc:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                break;                                                
                                                                      
            *ret = cur_cln;                                           
40013dd0:	c2 27 40 00 	st  %g1, [ %i5 ]                               
            break;                                                    
40013dd4:	81 c7 e0 08 	ret                                            
40013dd8:	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)) &&                       
40013ddc:	80 a0 60 00 	cmp  %g1, 0                                    
40013de0:	32 bf ff f4 	bne,a   40013db0 <fat_file_ioctl+0x68>         <== NEVER TAKEN
40013de4:	d4 0e 20 08 	ldub  [ %i0 + 8 ], %o2                         <== NOT EXECUTED
                (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))        
40013de8:	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)) &&                       
40013dec:	80 88 60 03 	btst  3, %g1                                   
40013df0:	22 bf ff f0 	be,a   40013db0 <fat_file_ioctl+0x68>          
40013df4:	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;                                            
40013df8:	c0 27 00 00 	clr  [ %i4 ]                                   
                rc = RC_OK;                                           
                break;                                                
40013dfc:	81 c7 e0 08 	ret                                            
40013e00:	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 );          
40013e04:	40 00 25 e3 	call  4001d590 <__errno>                       <== NOT EXECUTED
40013e08:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013e0c:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40013e10:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40013e14:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013e18:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400135ec <fat_file_lseek>: fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd, uint32_t file_cln, uint32_t *disk_cln ) {
400135ec:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int rc = RC_OK;                                                   
                                                                      
    if (file_cln == fat_fd->map.file_cln)                             
400135f0:	f8 06 60 34 	ld  [ %i1 + 0x34 ], %i4                        
400135f4:	80 a7 00 1a 	cmp  %i4, %i2                                  
400135f8:	22 80 00 26 	be,a   40013690 <fat_file_lseek+0xa4>          
400135fc:	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)                          
40013600:	2a 80 00 19 	bcs,a   40013664 <fat_file_lseek+0x78>         
40013604:	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;                                    
40013608:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
4001360c:	b8 10 00 1a 	mov  %i2, %i4                                  
40013610:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
            count = file_cln;                                         
        }                                                             
                                                                      
        /* skip over the clusters */                                  
        for (i = 0; i < count; i++)                                   
40013614:	80 a7 20 00 	cmp  %i4, 0                                    
40013618:	12 80 00 07 	bne  40013634 <fat_file_lseek+0x48>            
4001361c:	ba 10 20 00 	clr  %i5                                       
                return rc;                                            
        }                                                             
                                                                      
        /* update cache */                                            
        fat_fd->map.file_cln = file_cln;                              
        fat_fd->map.disk_cln = cur_cln;                               
40013620:	10 80 00 14 	b  40013670 <fat_file_lseek+0x84>              
40013624:	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++)                                   
40013628:	80 a7 40 1c 	cmp  %i5, %i4                                  
4001362c:	02 80 00 11 	be  40013670 <fat_file_lseek+0x84>             
40013630:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
        {                                                             
            rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);     
40013634:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
40013638:	90 10 00 18 	mov  %i0, %o0                                  
4001363c:	40 00 1f 40 	call  4001b33c <fat_get_fat_cluster>           
40013640:	94 07 bf fc 	add  %fp, -4, %o2                              
            if ( rc != RC_OK )                                        
40013644:	80 a2 20 00 	cmp  %o0, 0                                    
40013648:	22 bf ff f8 	be,a   40013628 <fat_file_lseek+0x3c>          <== ALWAYS TAKEN
4001364c:	ba 07 60 01 	inc  %i5                                       
                return rc;                                            
40013650:	86 10 00 08 	mov  %o0, %g3                                  <== NOT EXECUTED
40013654:	85 3a 20 1f 	sra  %o0, 0x1f, %g2                            <== NOT EXECUTED
        fat_fd->map.disk_cln = cur_cln;                               
                                                                      
        *disk_cln = cur_cln;                                          
    }                                                                 
    return RC_OK;                                                     
}                                                                     
40013658:	b2 10 00 03 	mov  %g3, %i1                                  <== NOT EXECUTED
4001365c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013660:	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;                  
40013664:	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;                           
40013668:	10 bf ff eb 	b  40013614 <fat_file_lseek+0x28>              
4001366c:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
            if ( rc != RC_OK )                                        
                return rc;                                            
        }                                                             
                                                                      
        /* update cache */                                            
        fat_fd->map.file_cln = file_cln;                              
40013670:	f4 26 60 34 	st  %i2, [ %i1 + 0x34 ]                        
        fat_fd->map.disk_cln = cur_cln;                               
40013674:	c2 26 60 38 	st  %g1, [ %i1 + 0x38 ]                        
                                                                      
        *disk_cln = cur_cln;                                          
    }                                                                 
    return RC_OK;                                                     
40013678:	84 10 20 00 	clr  %g2                                       
4001367c:	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;                                          
40013680:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    }                                                                 
    return RC_OK;                                                     
}                                                                     
40013684:	b0 10 00 02 	mov  %g2, %i0                                  
40013688:	81 c7 e0 08 	ret                                            
4001368c:	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;                                                     
40013690:	84 10 20 00 	clr  %g2                                       
40013694:	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;                             
40013698:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
        fat_fd->map.disk_cln = cur_cln;                               
                                                                      
        *disk_cln = cur_cln;                                          
    }                                                                 
    return RC_OK;                                                     
}                                                                     
4001369c:	b0 10 00 02 	mov  %g2, %i0                                  
400136a0:	81 c7 e0 08 	ret                                            
400136a4:	93 e8 00 03 	restore  %g0, %g3, %o1                         
                                                                      

400142d4 <fat_file_mark_removed>: void fat_file_mark_removed( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd ) {
400142d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
400142d8:	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)                                                     
400142dc:	80 a0 60 01 	cmp  %g1, 1                                    
400142e0:	02 80 00 26 	be  40014378 <fat_file_mark_removed+0xa4>      <== NEVER TAKEN
400142e4:	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)) )
400142e8:	32 80 00 1f 	bne,a   40014364 <fat_file_mark_removed+0x90>  <== NEVER TAKEN
400142ec:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
400142f0:	c4 0e 20 0e 	ldub  [ %i0 + 0xe ], %g2                       
400142f4:	80 88 a0 03 	btst  3, %g2                                   
400142f8:	22 80 00 1b 	be,a   40014364 <fat_file_mark_removed+0x90>   <== NEVER TAKEN
400142fc:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40014300:	fa 06 20 20 	ld  [ %i0 + 0x20 ], %i5                        
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(fs_info, cln) <<            
40014304:	c4 0e 20 03 	ldub  [ %i0 + 3 ], %g2                         
40014308:	bb 2f 40 02 	sll  %i5, %g2, %i5                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
4001430c:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
40014310:	90 10 00 19 	mov  %i1, %o0                                  
40014314:	87 30 a0 09 	srl  %g2, 9, %g3                               
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
40014318:	85 30 a0 05 	srl  %g2, 5, %g2                               
4001431c:	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) +  
40014320:	ba 07 40 03 	add  %i5, %g3, %i5                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
40014324:	bb 2f 60 04 	sll  %i5, 4, %i5                               
40014328:	40 00 0d f6 	call  40017b00 <_Chain_Extract>                
4001432c:	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);
40014330:	d0 06 20 70 	ld  [ %i0 + 0x70 ], %o0                        
40014334:	82 0f 60 01 	and  %i5, 1, %g1                               
40014338:	85 28 60 02 	sll  %g1, 2, %g2                               
4001433c:	83 28 60 04 	sll  %g1, 4, %g1                               
40014340:	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 );                               
40014344:	92 10 00 19 	mov  %i1, %o1                                  
40014348:	7f ff db 7d 	call  4000b13c <_Chain_Append>                 
4001434c:	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;                                
40014350:	c2 0e 60 30 	ldub  [ %i1 + 0x30 ], %g1                      
40014354:	82 10 60 01 	or  %g1, 1, %g1                                
40014358:	c2 2e 60 30 	stb  %g1, [ %i1 + 0x30 ]                       
4001435c:	81 c7 e0 08 	ret                                            
40014360:	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) +        
40014364:	c4 06 20 34 	ld  [ %i0 + 0x34 ], %g2                        <== NOT EXECUTED
40014368:	ba 00 7f fe 	add  %g1, -2, %i5                              <== NOT EXECUTED
4001436c:	bb 2f 40 03 	sll  %i5, %g3, %i5                             <== NOT EXECUTED
40014370:	10 bf ff e5 	b  40014304 <fat_file_mark_removed+0x30>       <== NOT EXECUTED
40014374:	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;                                                     
40014378:	10 bf ff e5 	b  4001430c <fat_file_mark_removed+0x38>       <== NOT EXECUTED
4001437c:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
                                                                      

400136a8 <fat_file_open>: fat_file_open( fat_fs_info_t *fs_info, fat_dir_pos_t *dir_pos, fat_file_fd_t **fat_fd ) {
400136a8:	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) +  
400136ac:	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)                                                     
400136b0:	80 a0 60 01 	cmp  %g1, 1                                    
400136b4:	02 80 00 9c 	be  40013924 <fat_file_open+0x27c>             
400136b8:	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)) )
400136bc:	32 80 00 7b 	bne,a   400138a8 <fat_file_open+0x200>         
400136c0:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         
400136c4:	c4 0e 20 0e 	ldub  [ %i0 + 0xe ], %g2                       
400136c8:	80 88 a0 03 	btst  3, %g2                                   
400136cc:	22 80 00 77 	be,a   400138a8 <fat_file_open+0x200>          <== NEVER TAKEN
400136d0:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
400136d4:	fa 06 20 20 	ld  [ %i0 + 0x20 ], %i5                        
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(fs_info, cln) <<            
400136d8:	c4 0e 20 03 	ldub  [ %i0 + 3 ], %g2                         
400136dc:	bb 2f 40 02 	sll  %i5, %g2, %i5                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
400136e0:	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);       
400136e4:	de 06 20 6c 	ld  [ %i0 + 0x6c ], %o7                        
400136e8:	85 30 60 09 	srl  %g1, 9, %g2                               
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
400136ec:	83 30 60 05 	srl  %g1, 5, %g1                               
400136f0:	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) +  
400136f4:	ba 07 40 02 	add  %i5, %g2, %i5                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
400136f8:	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) +  
400136fc:	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;                 
40013700:	82 0f 60 01 	and  %i5, 1, %g1                               
    rtems_chain_node *the_node = rtems_chain_first(hash + mod);       
40013704:	85 28 60 02 	sll  %g1, 2, %g2                               
40013708:	b7 28 60 04 	sll  %g1, 4, %i3                               
4001370c:	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;                              
40013710:	c2 03 c0 1b 	ld  [ %o7 + %i3 ], %g1                         
40013714:	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 ));            
40013718:	9e 03 e0 04 	add  %o7, 4, %o7                               
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
4001371c:	80 a0 40 0f 	cmp  %g1, %o7                                  
40013720:	22 80 00 1e 	be,a   40013798 <fat_file_open+0xf0>           
40013724:	c4 06 20 70 	ld  [ %i0 + 0x70 ], %g2                        
40013728:	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)                                                     
4001372c:	80 a0 a0 01 	cmp  %g2, 1                                    
40013730:	02 80 00 6d 	be  400138e4 <fat_file_open+0x23c>             
40013734:	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)) )
40013738:	32 80 00 61 	bne,a   400138bc <fat_file_open+0x214>         
4001373c:	c8 0e 20 05 	ldub  [ %i0 + 5 ], %g4                         
40013740:	c6 0e 20 0e 	ldub  [ %i0 + 0xe ], %g3                       
40013744:	80 88 e0 03 	btst  3, %g3                                   
40013748:	22 80 00 5d 	be,a   400138bc <fat_file_open+0x214>          <== NEVER TAKEN
4001374c:	c8 0e 20 05 	ldub  [ %i0 + 5 ], %g4                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40013750:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
                                                                      
    return (fat_cluster_num_to_sector_num(fs_info, cln) <<            
40013754:	c6 0e 20 03 	ldub  [ %i0 + 3 ], %g3                         
40013758:	b9 2f 00 03 	sll  %i4, %g3, %i4                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
4001375c:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3                        
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
40013760:	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)              +  
40013764:	89 30 e0 09 	srl  %g3, 9, %g4                               
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
40013768:	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) +  
4001376c:	86 07 00 04 	add  %i4, %g4, %g3                             
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
40013770:	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) +  
40013774:	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)                                            
40013778:	80 a7 40 03 	cmp  %i5, %g3                                  
4001377c:	22 80 00 55 	be,a   400138d0 <fat_file_open+0x228>          
40013780:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
            {                                                         
                *ret = (void *)the_node;                              
                return 0;                                             
            }                                                         
        }                                                             
        the_node = the_node->next;                                    
40013784:	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) ; )          
40013788:	80 a3 c0 01 	cmp  %o7, %g1                                  
4001378c:	32 bf ff e8 	bne,a   4001372c <fat_file_open+0x84>          
40013790:	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);       
40013794:	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;                              
40013798:	c2 00 80 1b 	ld  [ %g2 + %i3 ], %g1                         
4001379c:	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 ));            
400137a0:	9e 00 a0 04 	add  %g2, 4, %o7                               
                                                                      
    for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )          
400137a4:	80 a0 40 0f 	cmp  %g1, %o7                                  
400137a8:	02 80 00 1e 	be  40013820 <fat_file_open+0x178>             <== ALWAYS TAKEN
400137ac:	a0 10 3f ff 	mov  -1, %l0                                   
400137b0:	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)                                                     
400137b4:	80 a0 a0 01 	cmp  %g2, 1                                    <== NOT EXECUTED
400137b8:	02 80 00 59 	be  4001391c <fat_file_open+0x274>             <== NOT EXECUTED
400137bc:	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)) )
400137c0:	32 80 00 4b 	bne,a   400138ec <fat_file_open+0x244>         <== NOT EXECUTED
400137c4:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
400137c8:	c6 0e 20 0e 	ldub  [ %i0 + 0xe ], %g3                       <== NOT EXECUTED
400137cc:	80 88 e0 03 	btst  3, %g3                                   <== NOT EXECUTED
400137d0:	22 80 00 47 	be,a   400138ec <fat_file_open+0x244>          <== NOT EXECUTED
400137d4:	c6 0e 20 05 	ldub  [ %i0 + 5 ], %g3                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
400137d8:	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) <<            
400137dc:	c8 0e 20 03 	ldub  [ %i0 + 3 ], %g4                         <== NOT EXECUTED
400137e0:	b9 2f 00 04 	sll  %i4, %g4, %i4                             <== NOT EXECUTED
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
400137e4:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3                        <== NOT EXECUTED
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
400137e8:	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)              +  
400137ec:	89 30 e0 09 	srl  %g3, 9, %g4                               <== NOT EXECUTED
              ((pos->ofs >> 5) & (FAT_DIRENTRIES_PER_SEC512 - 1)) );  
400137f0:	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) +  
400137f4:	86 07 00 04 	add  %i4, %g4, %g3                             <== NOT EXECUTED
              (pos->ofs >> FAT_SECTOR512_BITS)) << 4)              +  
400137f8:	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) +  
400137fc:	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)                                            
40013800:	80 a7 40 03 	cmp  %i5, %g3                                  <== NOT EXECUTED
40013804:	02 80 00 3f 	be  40013900 <fat_file_open+0x258>             <== NOT EXECUTED
40013808:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
            {                                                         
                *ret = (void *)the_node;                              
                return 0;                                             
            }                                                         
        }                                                             
        the_node = the_node->next;                                    
4001380c:	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) ; )          
40013810:	80 a0 40 0f 	cmp  %g1, %o7                                  <== NOT EXECUTED
40013814:	32 bf ff e8 	bne,a   400137b4 <fat_file_open+0x10c>         <== NOT EXECUTED
40013818:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2                        <== NOT EXECUTED
                return 0;                                             
            }                                                         
        }                                                             
        the_node = the_node->next;                                    
    }                                                                 
    return -1;                                                        
4001381c:	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));
40013820:	7f ff ca ae 	call  400062d8 <malloc>                        
40013824:	90 10 20 44 	mov  0x44, %o0                                 
40013828:	d0 26 80 00 	st  %o0, [ %i2 ]                               
    if ( lfat_fd == NULL )                                            
4001382c:	80 a2 20 00 	cmp  %o0, 0                                    
40013830:	02 80 00 46 	be  40013948 <fat_file_open+0x2a0>             <== NEVER TAKEN
40013834:	b8 10 00 08 	mov  %o0, %i4                                  
        rtems_set_errno_and_return_minus_one( ENOMEM );               
                                                                      
    memset(lfat_fd, 0, sizeof(fat_file_fd_t));                        
40013838:	92 10 20 00 	clr  %o1                                       
4001383c:	40 00 2a 37 	call  4001e118 <memset>                        
40013840:	94 10 20 44 	mov  0x44, %o2                                 
                                                                      
    lfat_fd->links_num = 1;                                           
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
40013844:	de 0f 20 30 	ldub  [ %i4 + 0x30 ], %o7                      
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
40013848:	c8 06 40 00 	ld  [ %i1 ], %g4                               
4001384c:	c6 06 60 04 	ld  [ %i1 + 4 ], %g3                           
40013850:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
40013854:	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;                              
40013858:	b2 0b ff fe 	and  %o7, -2, %i1                              
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
4001385c:	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;                                           
40013860:	9e 10 20 01 	mov  1, %o7                                    
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
40013864:	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;                                           
40013868:	de 27 20 08 	st  %o7, [ %i4 + 8 ]                           
    lfat_fd->flags &= ~FAT_FILE_REMOVED;                              
    lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;                      
4001386c:	b2 10 3f ff 	mov  -1, %i1                                   
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
40013870:	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;                      
40013874:	f2 27 20 3c 	st  %i1, [ %i4 + 0x3c ]                        
                                                                      
    lfat_fd->dir_pos = *dir_pos;                                      
40013878:	c4 27 20 28 	st  %g2, [ %i4 + 0x28 ]                        
                                                                      
    if ( rc != RC_OK )                                                
4001387c:	80 a4 20 00 	cmp  %l0, 0                                    
40013880:	02 80 00 2b 	be  4001392c <fat_file_open+0x284>             <== NEVER TAKEN
40013884:	c2 27 20 2c 	st  %g1, [ %i4 + 0x2c ]                        
        lfat_fd->ino = key;                                           
40013888:	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);
4001388c:	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 );                               
40013890:	92 10 00 1c 	mov  %i4, %o1                                  
40013894:	90 02 00 1b 	add  %o0, %i3, %o0                             
40013898:	7f ff de 29 	call  4000b13c <_Chain_Append>                 
4001389c:	b0 10 20 00 	clr  %i0                                       
400138a0:	81 c7 e0 08 	ret                                            
400138a4:	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) +        
400138a8:	c4 06 20 34 	ld  [ %i0 + 0x34 ], %g2                        
400138ac:	ba 00 7f fe 	add  %g1, -2, %i5                              
400138b0:	bb 2f 40 03 	sll  %i5, %g3, %i5                             
400138b4:	10 bf ff 89 	b  400136d8 <fat_file_open+0x30>               
400138b8:	ba 07 40 02 	add  %i5, %g2, %i5                             
400138bc:	c6 06 20 34 	ld  [ %i0 + 0x34 ], %g3                        
400138c0:	b8 00 bf fe 	add  %g2, -2, %i4                              
400138c4:	b9 2f 00 04 	sll  %i4, %g4, %i4                             
400138c8:	10 bf ff a3 	b  40013754 <fat_file_open+0xac>               
400138cc:	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;                                          
400138d0:	c2 26 80 00 	st  %g1, [ %i2 ]                               
        lfat_fd->links_num++;                                         
400138d4:	84 00 a0 01 	inc  %g2                                       
400138d8:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
400138dc:	81 c7 e0 08 	ret                                            
400138e0:	91 e8 20 00 	restore  %g0, 0, %o0                           
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
400138e4:	10 bf ff 9e 	b  4001375c <fat_file_open+0xb4>               
400138e8:	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) +        
400138ec:	c8 06 20 34 	ld  [ %i0 + 0x34 ], %g4                        <== NOT EXECUTED
400138f0:	b8 00 bf fe 	add  %g2, -2, %i4                              <== NOT EXECUTED
400138f4:	b9 2f 00 03 	sll  %i4, %g3, %i4                             <== NOT EXECUTED
400138f8:	10 bf ff b9 	b  400137dc <fat_file_open+0x134>              <== NOT EXECUTED
400138fc:	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) )              
40013900:	02 bf ff c8 	be  40013820 <fat_file_open+0x178>             <== NOT EXECUTED
40013904:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
40013908:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         <== NOT EXECUTED
4001390c:	80 a7 40 02 	cmp  %i5, %g2                                  <== NOT EXECUTED
40013910:	32 bf ff c0 	bne,a   40013810 <fat_file_open+0x168>         <== NOT EXECUTED
40013914:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
40013918:	30 bf ff c2 	b,a   40013820 <fat_file_open+0x178>           <== NOT EXECUTED
    const fat_fs_info_t *fs_info,                                     
    uint32_t             cln                                          
    )                                                                 
{                                                                     
    if (cln == 1)                                                     
        return 1;                                                     
4001391c:	10 bf ff b2 	b  400137e4 <fat_file_open+0x13c>              <== NOT EXECUTED
40013920:	b8 10 20 01 	mov  1, %i4                                    <== NOT EXECUTED
40013924:	10 bf ff 6f 	b  400136e0 <fat_file_open+0x38>               
40013928:	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);                   
4001392c:	40 00 07 23 	call  400155b8 <fat_get_unique_ino>            <== NOT EXECUTED
40013930:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
                                                                      
        if ( lfat_fd->ino == 0 )                                      
40013934:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40013938:	12 bf ff d5 	bne  4001388c <fat_file_open+0x1e4>            <== NOT EXECUTED
4001393c:	d0 27 20 0c 	st  %o0, [ %i4 + 0xc ]                         <== NOT EXECUTED
        {                                                             
            free((*fat_fd));                                          
40013940:	7f ff c9 13 	call  40005d8c <free>                          <== NOT EXECUTED
40013944:	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 );           
40013948:	40 00 27 12 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001394c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40013950:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
40013954:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40013958:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001395c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40013978 <fat_file_read>: fat_file_fd_t *fat_fd, uint32_t start, uint32_t count, uint8_t *buf ) {
40013978:	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;                                       
4001397c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              start,                      
    uint32_t                              count,                      
    uint8_t                              *buf                         
)                                                                     
{                                                                     
40013980:	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)                                                   
40013984:	80 a6 e0 00 	cmp  %i3, 0                                    
40013988:	02 80 00 7f 	be  40013b84 <fat_file_read+0x20c>             <== NEVER TAKEN
4001398c:	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 )                             
40013990:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
40013994:	80 a0 40 1a 	cmp  %g1, %i2                                  
40013998:	08 80 00 7b 	bleu  40013b84 <fat_file_read+0x20c>           
4001399c:	80 a6 c0 01 	cmp  %i3, %g1                                  
        return FAT_EOF;                                               
                                                                      
    if ((count > fat_fd->fat_file_size) ||                            
400139a0:	08 80 00 4c 	bleu  40013ad0 <fat_file_read+0x158>           <== ALWAYS TAKEN
400139a4:	84 20 40 1b 	sub  %g1, %i3, %g2                             
        (start > fat_fd->fat_file_size - count))                      
        count = fat_fd->fat_file_size - start;                        
400139a8:	b6 20 40 1a 	sub  %g1, %i2, %i3                             <== NOT EXECUTED
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
400139ac:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
400139b0:	80 a0 60 01 	cmp  %g1, 1                                    
400139b4:	22 80 00 4c 	be,a   40013ae4 <fat_file_read+0x16c>          
400139b8:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
            return -1;                                                
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
400139bc:	e4 0f 60 08 	ldub  [ %i5 + 8 ], %l2                         
    save_ofs = ofs = start & (fs_info->vol.bpc - 1);                  
400139c0:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         
            return -1;                                                
                                                                      
        return ret;                                                   
    }                                                                 
                                                                      
    cl_start = start >> fs_info->vol.bpc_log2;                        
400139c4:	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);         
400139c8:	90 10 00 1d 	mov  %i5, %o0                                  
400139cc:	92 10 00 19 	mov  %i1, %o1                                  
400139d0:	94 10 00 12 	mov  %l2, %o2                                  
400139d4:	7f ff ff 06 	call  400135ec <fat_file_lseek>                
400139d8:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc != RC_OK)                                                  
400139dc:	b0 92 60 00 	orcc  %o1, 0, %i0                              
400139e0:	12 80 00 69 	bne  40013b84 <fat_file_read+0x20c>            <== NEVER TAKEN
400139e4:	a1 2c 20 10 	sll  %l0, 0x10, %l0                            
        return rc;                                                    
                                                                      
    while (count > 0)                                                 
400139e8:	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);                  
400139ec:	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)                                                 
400139f0:	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);                  
400139f4:	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)                                                 
400139f8:	80 a6 e0 00 	cmp  %i3, 0                                    
400139fc:	02 80 00 5b 	be  40013b68 <fat_file_read+0x1f0>             <== NEVER TAKEN
40013a00:	b4 0e 80 10 	and  %i2, %l0, %i2                             
40013a04:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
40013a08:	c8 17 40 00 	lduh  [ %i5 ], %g4                             
40013a0c:	10 80 00 20 	b  40013a8c <fat_file_read+0x114>              
40013a10:	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)) )
40013a14:	80 8e 20 03 	btst  3, %i0                                   <== NOT EXECUTED
40013a18:	22 80 00 27 	be,a   40013ab4 <fat_file_read+0x13c>          <== NOT EXECUTED
40013a1c:	de 0f 60 05 	ldub  [ %i5 + 5 ], %o7                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40013a20:	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);                        
40013a24:	87 32 80 03 	srl  %o2, %g3, %g3                             
        byte = ofs & (fs_info->vol.bps - 1);                          
40013a28:	85 29 20 10 	sll  %g4, 0x10, %g2                            
40013a2c:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
40013a30:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
        ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);   
40013a34:	98 07 00 11 	add  %i4, %l1, %o4                             
40013a38:	94 0a 80 02 	and  %o2, %g2, %o2                             
40013a3c:	92 02 40 03 	add  %o1, %g3, %o1                             
40013a40:	96 10 00 10 	mov  %l0, %o3                                  
40013a44:	40 00 03 25 	call  400146d8 <_fat_block_read>               
40013a48:	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);         
40013a4c:	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 )                                                
40013a50:	80 a2 20 00 	cmp  %o0, 0                                    
40013a54:	06 80 00 3d 	bl  40013b48 <fat_file_read+0x1d0>             <== NEVER TAKEN
40013a58:	90 10 00 1d 	mov  %i5, %o0                                  
            return -1;                                                
                                                                      
        count -= c;                                                   
        cmpltd += c;                                                  
        save_cln = cur_cln;                                           
40013a5c:	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;                                                   
40013a60:	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);         
40013a64:	92 10 00 13 	mov  %l3, %o1                                  
40013a68:	40 00 1e 35 	call  4001b33c <fat_get_fat_cluster>           
40013a6c:	a2 04 40 10 	add  %l1, %l0, %l1                             
        if ( rc != RC_OK )                                            
40013a70:	80 a2 20 00 	cmp  %o0, 0                                    
40013a74:	12 80 00 15 	bne  40013ac8 <fat_file_read+0x150>            <== NEVER TAKEN
40013a78:	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)                                                 
40013a7c:	02 80 00 3a 	be  40013b64 <fat_file_read+0x1ec>             
40013a80:	94 10 20 00 	clr  %o2                                       
40013a84:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
40013a88:	c8 17 40 00 	lduh  [ %i5 ], %g4                             
    {                                                                 
        c = MIN(count, (fs_info->vol.bpc - ofs));                     
40013a8c:	e0 17 60 06 	lduh  [ %i5 + 6 ], %l0                         
40013a90:	a0 24 00 0a 	sub  %l0, %o2, %l0                             
40013a94:	80 a4 00 1b 	cmp  %l0, %i3                                  
40013a98:	08 80 00 03 	bleu  40013aa4 <fat_file_read+0x12c>           
40013a9c:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
40013aa0:	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)) )
40013aa4:	80 a0 a0 00 	cmp  %g2, 0                                    
40013aa8:	22 bf ff db 	be,a   40013a14 <fat_file_read+0x9c>           <== NEVER TAKEN
40013aac:	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) +        
40013ab0:	de 0f 60 05 	ldub  [ %i5 + 5 ], %o7                         
40013ab4:	f0 07 60 34 	ld  [ %i5 + 0x34 ], %i0                        
40013ab8:	92 00 bf fe 	add  %g2, -2, %o1                              
40013abc:	93 2a 40 0f 	sll  %o1, %o7, %o1                             
40013ac0:	10 bf ff d9 	b  40013a24 <fat_file_read+0xac>               
40013ac4:	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;                                                    
}                                                                     
40013ac8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013acc:	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) ||                            
40013ad0:	80 a6 80 02 	cmp  %i2, %g2                                  
40013ad4:	28 bf ff b7 	bleu,a   400139b0 <fat_file_read+0x38>         
40013ad8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
        (start > fat_fd->fat_file_size - count))                      
        count = fat_fd->fat_file_size - start;                        
40013adc:	10 bf ff b4 	b  400139ac <fat_file_read+0x34>               
40013ae0:	b6 20 40 1a 	sub  %g1, %i2, %i3                             
                                                                      
    if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&                               
40013ae4:	80 a0 60 00 	cmp  %g1, 0                                    
40013ae8:	32 bf ff b6 	bne,a   400139c0 <fat_file_read+0x48>          <== NEVER TAKEN
40013aec:	e4 0f 60 08 	ldub  [ %i5 + 8 ], %l2                         <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
40013af0:	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)) &&                               
40013af4:	80 88 60 03 	btst  3, %g1                                   
40013af8:	22 bf ff b2 	be,a   400139c0 <fat_file_read+0x48>           
40013afc:	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);    
40013b00:	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)) )
40013b04:	80 a0 60 00 	cmp  %g1, 0                                    
40013b08:	32 80 00 12 	bne,a   40013b50 <fat_file_read+0x1d8>         <== NEVER TAKEN
40013b0c:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40013b10:	d2 07 60 20 	ld  [ %i5 + 0x20 ], %o1                        
        sec += (start >> fs_info->vol.sec_log2);                      
40013b14:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         
        byte = start & (fs_info->vol.bps - 1);                        
40013b18:	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);                      
40013b1c:	83 36 80 01 	srl  %i2, %g1, %g1                             
        byte = start & (fs_info->vol.bps - 1);                        
40013b20:	94 02 bf ff 	add  %o2, -1, %o2                              
                                                                      
        ret = _fat_block_read(fs_info, sec, byte, count, buf);        
40013b24:	90 10 00 1d 	mov  %i5, %o0                                  
40013b28:	92 02 40 01 	add  %o1, %g1, %o1                             
40013b2c:	94 0e 80 0a 	and  %i2, %o2, %o2                             
40013b30:	96 10 00 1b 	mov  %i3, %o3                                  
40013b34:	40 00 02 e9 	call  400146d8 <_fat_block_read>               
40013b38:	98 10 00 1c 	mov  %i4, %o4                                  
        if ( ret < 0 )                                                
40013b3c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40013b40:	16 80 00 11 	bge  40013b84 <fat_file_read+0x20c>            <== ALWAYS TAKEN
40013b44:	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;                                                
40013b48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013b4c:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
40013b50:	c4 07 60 34 	ld  [ %i5 + 0x34 ], %g2                        <== NOT EXECUTED
40013b54:	92 00 7f fe 	add  %g1, -2, %o1                              <== NOT EXECUTED
40013b58:	93 2a 40 03 	sll  %o1, %g3, %o1                             <== NOT EXECUTED
40013b5c:	10 bf ff ee 	b  40013b14 <fat_file_read+0x19c>              <== NOT EXECUTED
40013b60:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
40013b64:	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);
40013b68:	c2 0f 60 08 	ldub  [ %i5 + 8 ], %g1                         
40013b6c:	b4 06 bf ff 	add  %i2, -1, %i2                              
    fat_fd->map.disk_cln = save_cln;                                  
40013b70:	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);
40013b74:	a2 06 80 11 	add  %i2, %l1, %l1                             
40013b78:	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 +                                 
40013b7c:	a4 04 40 12 	add  %l1, %l2, %l2                             
40013b80:	e4 26 60 34 	st  %l2, [ %i1 + 0x34 ]                        
40013b84:	81 c7 e0 08 	ret                                            
40013b88:	81 e8 00 00 	restore                                        
                                                                      

40014380 <fat_file_size>: int fat_file_size( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd ) {
40014380:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int            rc = RC_OK;                                        
    uint32_t       cur_cln = fat_fd->cln;                             
40014384:	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)) &&                               
40014388:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
4001438c:	80 a0 60 01 	cmp  %g1, 1                                    
40014390:	02 80 00 21 	be  40014414 <fat_file_size+0x94>              
40014394:	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)      
40014398:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4001439c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
400143a0:	84 0f 00 02 	and  %i4, %g2, %g2                             
400143a4:	80 a0 80 01 	cmp  %g2, %g1                                  
400143a8:	0a 80 00 0e 	bcs  400143e0 <fat_file_size+0x60>             <== ALWAYS TAKEN
400143ac:	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;                                      
400143b0:	10 80 00 15 	b  40014404 <fat_file_size+0x84>               <== NOT EXECUTED
400143b4:	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;                    
400143b8:	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)      
400143bc:	c6 06 20 10 	ld  [ %i0 + 0x10 ], %g3                        
400143c0:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
400143c4:	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;                    
400143c8:	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)      
400143cc:	86 08 40 03 	and  %g1, %g3, %g3                             
400143d0:	80 a0 c0 02 	cmp  %g3, %g2                                  
400143d4:	1a 80 00 0c 	bcc  40014404 <fat_file_size+0x84>             <== ALWAYS TAKEN
400143d8:	c8 26 60 18 	st  %g4, [ %i1 + 0x18 ]                        
400143dc:	b8 10 00 01 	mov  %g1, %i4                                  <== NOT EXECUTED
    {                                                                 
        save_cln = cur_cln;                                           
        rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);         
400143e0:	92 10 00 1c 	mov  %i4, %o1                                  
400143e4:	90 10 00 18 	mov  %i0, %o0                                  
400143e8:	40 00 1b d5 	call  4001b33c <fat_get_fat_cluster>           
400143ec:	94 07 bf fc 	add  %fp, -4, %o2                              
        if ( rc != RC_OK )                                            
400143f0:	80 a2 20 00 	cmp  %o0, 0                                    
400143f4:	22 bf ff f1 	be,a   400143b8 <fat_file_size+0x38>           <== ALWAYS TAKEN
400143f8:	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;                                                        
}                                                                     
400143fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014400:	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;                                  
40014404:	90 10 20 00 	clr  %o0                                       
40014408:	f8 26 60 3c 	st  %i4, [ %i1 + 0x3c ]                        
    return rc;                                                        
}                                                                     
4001440c:	81 c7 e0 08 	ret                                            
40014410:	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)) &&                               
40014414:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
40014418:	80 a0 60 00 	cmp  %g1, 0                                    
4001441c:	32 bf ff e0 	bne,a   4001439c <fat_file_size+0x1c>          <== NEVER TAKEN
40014420:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        <== NOT EXECUTED
        (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))                
40014424:	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)) &&                               
40014428:	80 88 60 03 	btst  3, %g1                                   
4001442c:	22 bf ff dc 	be,a   4001439c <fat_file_size+0x1c>           <== ALWAYS TAKEN
40014430:	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;               
40014434:	c2 06 20 2c 	ld  [ %i0 + 0x2c ], %g1                        <== NOT EXECUTED
        return rc;                                                    
40014438:	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;               
4001443c:	10 bf ff f0 	b  400143fc <fat_file_size+0x7c>               <== NOT EXECUTED
40014440:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        <== NOT EXECUTED
                                                                      

40013b8c <fat_file_truncate>: fat_file_truncate( fat_fs_info_t *fs_info, fat_file_fd_t *fat_fd, uint32_t new_length ) {
40013b8c:	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 )                        
40013b90:	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;                
40013b94:	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;                                       
40013b98:	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 )                        
40013b9c:	80 a0 40 1a 	cmp  %g1, %i2                                  
40013ba0:	08 80 00 26 	bleu  40013c38 <fat_file_truncate+0xac>        
40013ba4:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
        return rc;                                                    
                                                                      
    assert(fat_fd->fat_file_size);                                    
40013ba8:	80 a0 60 00 	cmp  %g1, 0                                    
40013bac:	02 80 00 31 	be  40013c70 <fat_file_truncate+0xe4>          <== NEVER TAKEN
40013bb0:	11 10 00 b7 	sethi  %hi(0x4002dc00), %o0                    
                                                                      
    cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
40013bb4:	c4 0e 20 08 	ldub  [ %i0 + 8 ], %g2                         
40013bb8:	c6 16 20 06 	lduh  [ %i0 + 6 ], %g3                         
40013bbc:	86 00 ff ff 	add  %g3, -1, %g3                              
40013bc0:	b4 00 c0 1a 	add  %g3, %i2, %i2                             
40013bc4:	b5 36 80 02 	srl  %i2, %g2, %i2                             
                                                                      
    if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size) 
40013bc8:	85 2e 80 02 	sll  %i2, %g2, %g2                             
40013bcc:	80 a0 40 02 	cmp  %g1, %g2                                  
40013bd0:	08 80 00 1a 	bleu  40013c38 <fat_file_truncate+0xac>        
40013bd4:	80 a6 a0 00 	cmp  %i2, 0                                    
        return RC_OK;                                                 
                                                                      
    if (cl_start != 0)                                                
40013bd8:	02 80 00 09 	be  40013bfc <fat_file_truncate+0x70>          
40013bdc:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
        rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
40013be0:	92 10 00 19 	mov  %i1, %o1                                  
40013be4:	94 06 bf ff 	add  %i2, -1, %o2                              
40013be8:	7f ff fe 81 	call  400135ec <fat_file_lseek>                
40013bec:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (rc != RC_OK)                                              
40013bf0:	80 a2 60 00 	cmp  %o1, 0                                    
40013bf4:	12 80 00 12 	bne  40013c3c <fat_file_truncate+0xb0>         <== NEVER TAKEN
40013bf8:	90 10 00 18 	mov  %i0, %o0                                  
            return rc;                                                
                                                                      
    }                                                                 
                                                                      
    rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);         
40013bfc:	92 10 00 19 	mov  %i1, %o1                                  
40013c00:	94 10 00 1a 	mov  %i2, %o2                                  
40013c04:	7f ff fe 7a 	call  400135ec <fat_file_lseek>                
40013c08:	96 07 bf f8 	add  %fp, -8, %o3                              
    if (rc != RC_OK)                                                  
40013c0c:	80 a2 60 00 	cmp  %o1, 0                                    
40013c10:	12 80 00 0b 	bne  40013c3c <fat_file_truncate+0xb0>         <== NEVER TAKEN
40013c14:	01 00 00 00 	nop                                            
        return rc;                                                    
                                                                      
    rc = fat_free_fat_clusters_chain(fs_info, cur_cln);               
40013c18:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
40013c1c:	40 00 1e fe 	call  4001b814 <fat_free_fat_clusters_chain>   
40013c20:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc != RC_OK)                                                  
40013c24:	92 92 20 00 	orcc  %o0, 0, %o1                              
40013c28:	12 80 00 05 	bne  40013c3c <fat_file_truncate+0xb0>         <== NEVER TAKEN
40013c2c:	80 a6 a0 00 	cmp  %i2, 0                                    
        return rc;                                                    
                                                                      
    if (cl_start != 0)                                                
40013c30:	12 80 00 05 	bne  40013c44 <fat_file_truncate+0xb8>         
40013c34:	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;                                                    
40013c38:	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;                                                     
}                                                                     
40013c3c:	81 c7 e0 08 	ret                                            
40013c40:	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);
40013c44:	90 10 00 18 	mov  %i0, %o0                                  
40013c48:	40 00 1e 41 	call  4001b54c <fat_set_fat_cluster>           
40013c4c:	94 10 3f ff 	mov  -1, %o2                                   
        if ( rc != RC_OK )                                            
40013c50:	92 92 20 00 	orcc  %o0, 0, %o1                              
40013c54:	12 bf ff fa 	bne  40013c3c <fat_file_truncate+0xb0>         <== NEVER TAKEN
40013c58:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            return rc;                                                
        fat_fd->map.file_cln = cl_start - 1;                          
40013c5c:	b4 06 bf ff 	add  %i2, -1, %i2                              
        fat_fd->map.disk_cln = new_last_cln;                          
40013c60:	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;                          
40013c64:	f4 26 60 34 	st  %i2, [ %i1 + 0x34 ]                        
        fat_fd->map.disk_cln = new_last_cln;                          
        fat_fd->map.last_cln = new_last_cln;                          
40013c68:	10 bf ff f5 	b  40013c3c <fat_file_truncate+0xb0>           
40013c6c:	c2 26 60 3c 	st  %g1, [ %i1 + 0x3c ]                        
                                                                      
                                                                      
    if ( new_length >= fat_fd->fat_file_size )                        
        return rc;                                                    
                                                                      
    assert(fat_fd->fat_file_size);                                    
40013c70:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
40013c74:	17 10 00 b7 	sethi  %hi(0x4002dc00), %o3                    <== NOT EXECUTED
40013c78:	90 12 22 b8 	or  %o0, 0x2b8, %o0                            <== NOT EXECUTED
40013c7c:	92 10 22 d1 	mov  0x2d1, %o1                                <== NOT EXECUTED
40013c80:	94 12 a3 18 	or  %o2, 0x318, %o2                            <== NOT EXECUTED
40013c84:	7f ff c7 de 	call  40005bfc <__assert_func>                 <== NOT EXECUTED
40013c88:	96 12 e3 00 	or  %o3, 0x300, %o3                            <== NOT EXECUTED
                                                                      

40014070 <fat_file_write>: fat_file_fd_t *fat_fd, uint32_t start, uint32_t count, const uint8_t *buf ) {
40014070:	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;                                             
40014074:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
    fat_file_fd_t                        *fat_fd,                     
    uint32_t                              start,                      
    uint32_t                              count,                      
    const uint8_t                        *buf                         
    )                                                                 
{                                                                     
40014078:	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;         
4001407c:	c2 06 60 18 	ld  [ %i1 + 0x18 ], %g1                        
    uint32_t       file_cln_initial = fat_fd->map.file_cln;           
40014080:	e4 06 60 34 	ld  [ %i1 + 0x34 ], %l2                        
    uint32_t       cln;                                               
                                                                      
                                                                      
    if ( count == 0 )                                                 
40014084:	80 a6 e0 00 	cmp  %i3, 0                                    
40014088:	02 80 00 5d 	be  400141fc <fat_file_write+0x18c>            <== NEVER TAKEN
4001408c:	b0 10 20 00 	clr  %i0                                       
        return cmpltd;                                                
                                                                      
    if (start >= fat_fd->size_limit)                                  
40014090:	fa 06 60 14 	ld  [ %i1 + 0x14 ], %i5                        
40014094:	80 a6 80 1d 	cmp  %i2, %i5                                  
40014098:	1a 80 00 89 	bcc  400142bc <fat_file_write+0x24c>           <== NEVER TAKEN
4001409c:	ba 27 40 1a 	sub  %i5, %i2, %i5                             
400140a0:	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;         
400140a4:	18 80 00 58 	bgu  40014204 <fat_file_write+0x194>           <== ALWAYS TAKEN
400140a8:	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);
400140ac:	b6 07 40 1a 	add  %i5, %i2, %i3                             <== NOT EXECUTED
400140b0:	94 40 20 00 	addx  %g0, 0, %o2                              <== NOT EXECUTED
400140b4:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
400140b8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
400140bc:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
400140c0:	7f ff ff 57 	call  40013e1c <fat_file_extend>               <== NOT EXECUTED
400140c4:	98 07 bf f8 	add  %fp, -8, %o4                              <== NOT EXECUTED
    if (RC_OK == rc)                                                  
400140c8:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
400140cc:	12 80 00 4c 	bne  400141fc <fat_file_write+0x18c>           <== NOT EXECUTED
400140d0:	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))                                     
400140d4:	80 a6 c0 01 	cmp  %i3, %g1                                  <== NOT EXECUTED
400140d8:	32 80 00 02 	bne,a   400140e0 <fat_file_write+0x70>         <== NEVER TAKEN
400140dc:	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));
400140e0:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
400140e4:	80 a0 60 01 	cmp  %g1, 1                                    
400140e8:	02 80 00 5b 	be  40014254 <fat_file_write+0x1e4>            
400140ec:	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;        
400140f0:	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;                                       
400140f4:	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;        
400140f8:	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);        
400140fc:	90 10 00 10 	mov  %l0, %o0                                  
40014100:	92 10 00 19 	mov  %i1, %o1                                  
40014104:	94 10 00 15 	mov  %l5, %o2                                  
40014108:	7f ff fd 39 	call  400135ec <fat_file_lseek>                
4001410c:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (RC_OK == rc)                                                  
40014110:	80 a2 60 00 	cmp  %o1, 0                                    
40014114:	12 80 00 38 	bne  400141f4 <fat_file_write+0x184>           <== NEVER TAKEN
40014118:	b0 92 60 00 	orcc  %o1, 0, %i0                              
    {                                                                 
        file_cln_cnt = cur_cln - fat_fd->cln;                         
4001411c:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
40014120:	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);
40014124:	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;                         
40014128:	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);
4001412c:	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;                         
40014130:	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);
40014134:	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;                         
40014138:	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 */
4001413c:	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;                                        
40014140:	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)                                       
40014144:	80 a7 60 00 	cmp  %i5, 0                                    
40014148:	22 80 00 21 	be,a   400141cc <fat_file_write+0x15c>         <== NEVER TAKEN
4001414c:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         <== NOT EXECUTED
40014150:	80 a6 20 00 	cmp  %i0, 0                                    
40014154:	32 80 00 1e 	bne,a   400141cc <fat_file_write+0x15c>        <== NEVER TAKEN
40014158:	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));    
4001415c:	d6 14 20 06 	lduh  [ %l0 + 6 ], %o3                         
40014160:	96 22 c0 11 	sub  %o3, %l1, %o3                             
40014164:	80 a2 c0 1d 	cmp  %o3, %i5                                  
40014168:	38 80 00 02 	bgu,a   40014170 <fat_file_write+0x100>        
4001416c:	96 10 00 1d 	mov  %i5, %o3                                  
                                                                      
            if (file_cln_initial < file_cln_cnt)                      
40014170:	80 a4 80 16 	cmp  %l2, %l6                                  
40014174:	2a 80 00 02 	bcs,a   4001417c <fat_file_write+0x10c>        
40014178:	a6 10 20 01 	mov  1, %l3                                    
                overwrite_cluster = true;                             
                                                                      
            ret = fat_cluster_write(fs_info,                          
4001417c:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
40014180:	90 10 00 10 	mov  %l0, %o0                                  
40014184:	94 10 00 11 	mov  %l1, %o2                                  
40014188:	98 07 00 1b 	add  %i4, %i3, %o4                             
4001418c:	9a 0c e0 01 	and  %l3, 1, %o5                               
40014190:	40 00 01 fe 	call  40014988 <fat_cluster_write>             
40014194:	b0 10 3f ff 	mov  -1, %i0                                   
                                      cur_cln,                        
                                      ofs_cln,                        
                                      c,                              
                                      &buf[cmpltd],                   
                                      overwrite_cluster);             
            if (0 > ret)                                              
40014198:	80 a2 20 00 	cmp  %o0, 0                                    
4001419c:	06 bf ff eb 	bl  40014148 <fat_file_write+0xd8>             <== NEVER TAKEN
400141a0:	80 a7 60 00 	cmp  %i5, 0                                    
              rc = -1;                                                
                                                                      
            if (RC_OK == rc)                                          
            {                                                         
                ++file_cln_cnt;                                       
400141a4:	ac 05 a0 01 	inc  %l6                                       
                bytes_to_write -= ret;                                
                cmpltd += ret;                                        
400141a8:	b6 06 c0 08 	add  %i3, %o0, %i3                             
                save_cln = cur_cln;                                   
                if (0 < bytes_to_write)                               
400141ac:	ba a7 40 08 	subcc  %i5, %o0, %i5                           
400141b0:	12 80 00 22 	bne  40014238 <fat_file_write+0x1c8>           
400141b4:	e8 07 bf fc 	ld  [ %fp + -4 ], %l4                          
400141b8:	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)                                       
400141bc:	80 a7 60 00 	cmp  %i5, 0                                    
400141c0:	12 bf ff e4 	bne  40014150 <fat_file_write+0xe0>            <== NEVER TAKEN
400141c4:	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);
400141c8:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
400141cc:	b4 06 bf ff 	add  %i2, -1, %i2                              
        fat_fd->map.disk_cln = save_cln;                              
400141d0:	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);
400141d4:	b4 06 80 1b 	add  %i2, %i3, %i2                             
400141d8:	b5 36 80 01 	srl  %i2, %g1, %i2                             
            }                                                         
        }                                                             
                                                                      
        /* update cache */                                            
        /* XXX: check this - I'm not sure :( */                       
        fat_fd->map.file_cln = start_cln +                            
400141dc:	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)                                                  
400141e0:	92 96 20 00 	orcc  %i0, 0, %o1                              
400141e4:	12 80 00 03 	bne  400141f0 <fat_file_write+0x180>           <== NEVER TAKEN
400141e8:	ea 26 60 34 	st  %l5, [ %i1 + 0x34 ]                        
      return rc;                                                      
    else                                                              
      return cmpltd;                                                  
400141ec:	92 10 00 1b 	mov  %i3, %o1                                  
                                                       fat_fd,        
                                                       start,         
                                                       count,         
                                                       buf,           
                                                       file_cln_initial);
            if (0 > ret)                                              
400141f0:	b0 92 60 00 	orcc  %o1, 0, %i0                              
400141f4:	06 80 00 30 	bl  400142b4 <fat_file_write+0x244>            <== NEVER TAKEN
400141f8:	01 00 00 00 	nop                                            
    }                                                                 
    if (RC_OK != rc)                                                  
        return rc;                                                    
    else                                                              
        return cmpltd;                                                
}                                                                     
400141fc:	81 c7 e0 08 	ret                                            
40014200:	81 e8 00 00 	restore                                        
40014204:	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);
40014208:	94 40 20 00 	addx  %g0, 0, %o2                              
4001420c:	b6 07 40 1a 	add  %i5, %i2, %i3                             
40014210:	90 10 00 10 	mov  %l0, %o0                                  
40014214:	92 10 00 19 	mov  %i1, %o1                                  
40014218:	96 10 00 1b 	mov  %i3, %o3                                  
4001421c:	7f ff ff 00 	call  40013e1c <fat_file_extend>               
40014220:	98 07 bf f8 	add  %fp, -8, %o4                              
    if (RC_OK == rc)                                                  
40014224:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40014228:	12 bf ff f5 	bne  400141fc <fat_file_write+0x18c>           
4001422c:	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))                                     
40014230:	10 bf ff aa 	b  400140d8 <fat_file_write+0x68>              
40014234:	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);
40014238:	90 10 00 10 	mov  %l0, %o0                                  
4001423c:	92 10 00 14 	mov  %l4, %o1                                  
40014240:	94 07 bf fc 	add  %fp, -4, %o2                              
40014244:	40 00 1c 3e 	call  4001b33c <fat_get_fat_cluster>           
40014248:	a2 10 20 00 	clr  %l1                                       
4001424c:	10 bf ff be 	b  40014144 <fat_file_write+0xd4>              
40014250:	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));
40014254:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
40014258:	80 a0 60 00 	cmp  %g1, 0                                    
4001425c:	32 bf ff a6 	bne,a   400140f4 <fat_file_write+0x84>         <== NEVER TAKEN
40014260:	f6 0c 20 08 	ldub  [ %l0 + 8 ], %i3                         <== NOT EXECUTED
40014264:	80 88 a0 03 	btst  3, %g2                                   
40014268:	22 bf ff a3 	be,a   400140f4 <fat_file_write+0x84>          
4001426c:	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;                                        
40014270:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
            cln += (start >> fs_info->vol.bpc_log2);                  
40014274:	d2 0c 20 08 	ldub  [ %l0 + 8 ], %o1                         
            byte = start & (fs_info->vol.bpc -1);                     
40014278:	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);                  
4001427c:	93 36 80 09 	srl  %i2, %o1, %o1                             
            byte = start & (fs_info->vol.bpc -1);                     
40014280:	94 02 bf ff 	add  %o2, -1, %o2                              
                                                                      
            ret = fat_cluster_write(fs_info,                          
40014284:	90 10 00 10 	mov  %l0, %o0                                  
40014288:	92 02 40 01 	add  %o1, %g1, %o1                             
4001428c:	94 0e 80 0a 	and  %i2, %o2, %o2                             
40014290:	96 10 00 1d 	mov  %i5, %o3                                  
40014294:	98 10 00 1c 	mov  %i4, %o4                                  
40014298:	40 00 01 bc 	call  40014988 <fat_cluster_write>             
4001429c:	9a 10 20 00 	clr  %o5                                       
                                      cln,                            
                                      byte,                           
                                      count,                          
                                      buf,                            
                                      false);                         
            if (0 > ret)                                              
400142a0:	80 a2 20 00 	cmp  %o0, 0                                    
400142a4:	06 80 00 04 	bl  400142b4 <fat_file_write+0x244>            <== NEVER TAKEN
400142a8:	01 00 00 00 	nop                                            
              rc = -1;                                                
            else                                                      
              cmpltd = ret;                                           
400142ac:	81 c7 e0 08 	ret                                            
400142b0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                       start,         
                                                       count,         
                                                       buf,           
                                                       file_cln_initial);
            if (0 > ret)                                              
              rc = -1;                                                
400142b4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400142b8:	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);                  
400142bc:	40 00 24 b5 	call  4001d590 <__errno>                       <== NOT EXECUTED
400142c0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400142c4:	82 10 20 1b 	mov  0x1b, %g1                                 <== NOT EXECUTED
400142c8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400142cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400142d0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001b814 <fat_free_fat_clusters_chain>: int fat_free_fat_clusters_chain( fat_fs_info_t *fs_info, uint32_t chain ) {
4001b814:	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)      
4001b818:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4001b81c:	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;                                      
4001b820:	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)      
4001b824:	84 0e 40 02 	and  %i1, %g2, %g2                             
4001b828:	80 a0 80 01 	cmp  %g2, %g1                                  
4001b82c:	1a 80 00 25 	bcc  4001b8c0 <fat_free_fat_clusters_chain+0xac><== NEVER TAKEN
4001b830:	ba 10 00 18 	mov  %i0, %i5                                  
4001b834:	b8 10 00 19 	mov  %i1, %i4                                  
4001b838:	b6 10 20 00 	clr  %i3                                       
4001b83c:	10 80 00 0e 	b  4001b874 <fat_free_fat_clusters_chain+0x60> 
4001b840:	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);  
4001b844:	7f ff ff 42 	call  4001b54c <fat_set_fat_cluster>           
4001b848:	01 00 00 00 	nop                                            
        if ( rc != RC_OK )                                            
4001b84c:	80 a2 20 00 	cmp  %o0, 0                                    
4001b850:	02 80 00 03 	be  4001b85c <fat_free_fat_clusters_chain+0x48><== ALWAYS TAKEN
4001b854:	f8 07 bf fc 	ld  [ %fp + -4 ], %i4                          
4001b858:	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)      
4001b85c:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
4001b860:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4001b864:	84 0f 00 02 	and  %i4, %g2, %g2                             
4001b868:	80 a0 80 01 	cmp  %g2, %g1                                  
4001b86c:	1a 80 00 17 	bcc  4001b8c8 <fat_free_fat_clusters_chain+0xb4>
4001b870:	b6 06 e0 01 	inc  %i3                                       
    {                                                                 
        rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);        
4001b874:	92 10 00 1c 	mov  %i4, %o1                                  
4001b878:	94 07 bf fc 	add  %fp, -4, %o2                              
4001b87c:	7f ff fe b0 	call  4001b33c <fat_get_fat_cluster>           
4001b880:	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);  
4001b884:	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);        
4001b888:	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);  
4001b88c:	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 )                                            
4001b890:	80 a6 20 00 	cmp  %i0, 0                                    
4001b894:	02 bf ff ec 	be  4001b844 <fat_free_fat_clusters_chain+0x30><== ALWAYS TAKEN
4001b898:	90 10 00 1d 	mov  %i5, %o0                                  
        {                                                             
              if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)        
4001b89c:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        <== NOT EXECUTED
4001b8a0:	80 a0 7f ff 	cmp  %g1, -1                                   <== NOT EXECUTED
4001b8a4:	02 80 00 03 	be  4001b8b0 <fat_free_fat_clusters_chain+0x9c><== NOT EXECUTED
4001b8a8:	82 06 c0 01 	add  %i3, %g1, %g1                             <== NOT EXECUTED
                fs_info->vol.free_cls += freed_cls_cnt;               
4001b8ac:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        <== NOT EXECUTED
                                                                      
            fat_buf_release(fs_info);                                 
4001b8b0:	7f ff e2 e5 	call  40014444 <fat_buf_release>               <== NOT EXECUTED
4001b8b4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001b8b8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b8bc:	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;                                 
4001b8c0:	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;                           
4001b8c4:	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)             
4001b8c8:	c2 07 60 44 	ld  [ %i5 + 0x44 ], %g1                        
4001b8cc:	80 a0 7f ff 	cmp  %g1, -1                                   
4001b8d0:	02 80 00 04 	be  4001b8e0 <fat_free_fat_clusters_chain+0xcc><== ALWAYS TAKEN
4001b8d4:	f2 27 60 4c 	st  %i1, [ %i5 + 0x4c ]                        
            fs_info->vol.free_cls += freed_cls_cnt;                   
4001b8d8:	82 06 c0 01 	add  %i3, %g1, %g1                             <== NOT EXECUTED
4001b8dc:	c2 27 60 44 	st  %g1, [ %i5 + 0x44 ]                        <== NOT EXECUTED
                                                                      
    fat_buf_release(fs_info);                                         
4001b8e0:	b0 10 00 1a 	mov  %i2, %i0                                  
4001b8e4:	7f ff e2 d8 	call  40014444 <fat_buf_release>               
4001b8e8:	90 10 00 1d 	mov  %i5, %o0                                  
    if (rc1 != RC_OK)                                                 
        return rc1;                                                   
                                                                      
    return RC_OK;                                                     
}                                                                     
4001b8ec:	81 c7 e0 08 	ret                                            
4001b8f0:	81 e8 00 00 	restore                                        
                                                                      

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

4001b33c <fat_get_fat_cluster>: fat_get_fat_cluster( fat_fs_info_t *fs_info, uint32_t cln, uint32_t *ret_val ) {
4001b33c:	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)) )           
4001b340:	80 a6 60 01 	cmp  %i1, 1                                    
4001b344:	08 80 00 27 	bleu  4001b3e0 <fat_get_fat_cluster+0xa4>      <== NEVER TAKEN
4001b348:	ba 10 00 18 	mov  %i0, %i5                                  
4001b34c:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
4001b350:	82 00 60 01 	inc  %g1                                       
4001b354:	80 a6 40 01 	cmp  %i1, %g1                                  
4001b358:	18 80 00 22 	bgu  4001b3e0 <fat_get_fat_cluster+0xa4>       <== NEVER TAKEN
4001b35c:	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) +
4001b360:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
4001b364:	80 88 60 01 	btst  1, %g1                                   
4001b368:	12 80 00 24 	bne  4001b3f8 <fat_get_fat_cluster+0xbc>       
4001b36c:	f6 0e 20 02 	ldub  [ %i0 + 2 ], %i3                         
4001b370:	82 08 60 02 	and  %g1, 2, %g1                               
4001b374:	80 88 60 ff 	btst  0xff, %g1                                
4001b378:	02 80 00 30 	be  4001b438 <fat_get_fat_cluster+0xfc>        
4001b37c:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
4001b380:	b9 2e 60 01 	sll  %i1, 1, %i4                               
4001b384:	b7 37 00 1b 	srl  %i4, %i3, %i3                             
4001b388:	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);
4001b38c:	e0 17 40 00 	lduh  [ %i5 ], %l0                             
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
4001b390:	90 10 00 1d 	mov  %i5, %o0                                  
4001b394:	92 10 00 1b 	mov  %i3, %o1                                  
4001b398:	94 10 20 01 	mov  1, %o2                                    
4001b39c:	7f ff e4 a1 	call  40014620 <fat_buf_access>                
4001b3a0:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc != RC_OK)                                                  
4001b3a4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001b3a8:	12 80 00 57 	bne  4001b504 <fat_get_fat_cluster+0x1c8>      <== NEVER TAKEN
4001b3ac:	01 00 00 00 	nop                                            
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
4001b3b0:	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);
4001b3b4:	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 )                                      
4001b3b8:	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);
4001b3bc:	a1 34 20 10 	srl  %l0, 0x10, %l0                            
4001b3c0:	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 )                                      
4001b3c4:	02 80 00 21 	be  4001b448 <fat_get_fat_cluster+0x10c>       
4001b3c8:	b8 0f 00 10 	and  %i4, %l0, %i4                             
4001b3cc:	80 a0 60 04 	cmp  %g1, 4                                    
4001b3d0:	02 80 00 3c 	be  4001b4c0 <fat_get_fat_cluster+0x184>       
4001b3d4:	80 a0 60 01 	cmp  %g1, 1                                    
4001b3d8:	02 80 00 28 	be  4001b478 <fat_get_fat_cluster+0x13c>       <== ALWAYS TAKEN
4001b3dc:	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);                
4001b3e0:	40 00 08 6c 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001b3e4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001b3e8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001b3ec:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001b3f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b3f4:	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) +
4001b3f8:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
4001b3fc:	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);
4001b400:	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) +
4001b404:	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);    
4001b408:	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) +
4001b40c:	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);    
4001b410:	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) +
4001b414:	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);    
4001b418:	96 07 bf fc 	add  %fp, -4, %o3                              
4001b41c:	7f ff e4 81 	call  40014620 <fat_buf_access>                
4001b420:	92 10 00 1b 	mov  %i3, %o1                                  
    if (rc != RC_OK)                                                  
4001b424:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001b428:	22 bf ff e3 	be,a   4001b3b4 <fat_get_fat_cluster+0x78>     <== ALWAYS TAKEN
4001b42c:	c2 0f 60 0e 	ldub  [ %i5 + 0xe ], %g1                       
            rtems_set_errno_and_return_minus_one(EIO);                
            break;                                                    
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
4001b430:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b434:	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) +
4001b438:	b9 2e 60 02 	sll  %i1, 2, %i4                               
4001b43c:	b7 37 00 1b 	srl  %i4, %i3, %i3                             
4001b440:	10 bf ff d3 	b  4001b38c <fat_get_fat_cluster+0x50>         
4001b444:	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));              
4001b448:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            *ret_val = CF_LE_W(*ret_val);                             
4001b44c:	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));              
4001b450:	c2 10 40 1c 	lduh  [ %g1 + %i4 ], %g1                       
            *ret_val = CF_LE_W(*ret_val);                             
4001b454:	86 10 e3 ff 	or  %g3, 0x3ff, %g3                            
4001b458:	83 28 60 10 	sll  %g1, 0x10, %g1                            
4001b45c:	85 30 60 18 	srl  %g1, 0x18, %g2                            
4001b460:	83 30 60 08 	srl  %g1, 8, %g1                               
4001b464:	82 08 40 03 	and  %g1, %g3, %g1                             
4001b468:	82 10 80 01 	or  %g2, %g1, %g1                              
4001b46c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
4001b470:	81 c7 e0 08 	ret                                            
4001b474:	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) )                      
4001b478:	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));                            
4001b47c:	c2 08 80 1c 	ldub  [ %g2 + %i4 ], %g1                       
            if ( ofs == (fs_info->vol.bps - 1) )                      
4001b480:	86 00 ff ff 	add  %g3, -1, %g3                              
4001b484:	80 a0 c0 1c 	cmp  %g3, %i4                                  
4001b488:	02 80 00 21 	be  4001b50c <fat_get_fat_cluster+0x1d0>       <== NEVER TAKEN
4001b48c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
                                                                      
                *ret_val |= *sec_buf << 8;                            
            }                                                         
            else                                                      
            {                                                         
                *ret_val |= *(sec_buf + ofs + 1) << 8;                
4001b490:	b8 00 80 1c 	add  %g2, %i4, %i4                             
4001b494:	c4 0f 20 01 	ldub  [ %i4 + 1 ], %g2                         
4001b498:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001b49c:	82 10 80 01 	or  %g2, %g1, %g1                              
4001b4a0:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            }                                                         
                                                                      
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
4001b4a4:	80 8e 60 01 	btst  1, %i1                                   
4001b4a8:	22 80 00 16 	be,a   4001b500 <fat_get_fat_cluster+0x1c4>    
4001b4ac:	82 08 6f ff 	and  %g1, 0xfff, %g1                           
                *ret_val = (*ret_val) >> FAT12_SHIFT;                 
4001b4b0:	83 30 60 04 	srl  %g1, 4, %g1                               
4001b4b4:	c2 26 80 00 	st  %g1, [ %i2 ]                               
4001b4b8:	81 c7 e0 08 	ret                                            
4001b4bc:	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));              
4001b4c0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001b4c4:	c2 00 40 1c 	ld  [ %g1 + %i4 ], %g1                         
4001b4c8:	89 28 60 18 	sll  %g1, 0x18, %g4                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
4001b4cc:	85 30 60 18 	srl  %g1, 0x18, %g2                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
4001b4d0:	87 30 60 08 	srl  %g1, 8, %g3                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b4d4:	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;                                       
4001b4d8:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4001b4dc:	83 30 60 10 	srl  %g1, 0x10, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b4e0:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4001b4e4:	82 08 60 ff 	and  %g1, 0xff, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b4e8:	84 10 80 03 	or  %g2, %g3, %g2                              
4001b4ec:	83 28 60 08 	sll  %g1, 8, %g1                               
4001b4f0:	82 10 80 01 	or  %g2, %g1, %g1                              
            *ret_val = CF_LE_L(*ret_val);                             
4001b4f4:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
4001b4f8:	81 c7 e0 08 	ret                                            
4001b4fc:	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;               
4001b500:	c2 26 80 00 	st  %g1, [ %i2 ]                               
4001b504:	81 c7 e0 08 	ret                                            
4001b508:	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,
4001b50c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001b510:	92 06 e0 01 	add  %i3, 1, %o1                               <== NOT EXECUTED
4001b514:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
4001b518:	7f ff e4 42 	call  40014620 <fat_buf_access>                <== NOT EXECUTED
4001b51c:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
                                    &sec_buf);                        
                if (rc != RC_OK)                                      
4001b520:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001b524:	12 80 00 08 	bne  4001b544 <fat_get_fat_cluster+0x208>      <== NOT EXECUTED
4001b528:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          <== NOT EXECUTED
                    return rc;                                        
                                                                      
                *ret_val |= *sec_buf << 8;                            
4001b52c:	c2 06 80 00 	ld  [ %i2 ], %g1                               <== NOT EXECUTED
4001b530:	c4 08 80 00 	ldub  [ %g2 ], %g2                             <== NOT EXECUTED
4001b534:	85 28 a0 08 	sll  %g2, 8, %g2                               <== NOT EXECUTED
4001b538:	82 10 80 01 	or  %g2, %g1, %g1                              <== NOT EXECUTED
4001b53c:	10 bf ff da 	b  4001b4a4 <fat_get_fat_cluster+0x168>        <== NOT EXECUTED
4001b540:	c2 26 80 00 	st  %g1, [ %i2 ]                               <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
            break;                                                    
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
4001b544:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b548:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

400155b8 <fat_get_unique_ino>: * 0 means FAILED !!! * */ uint32_t fat_get_unique_ino(fat_fs_info_t *fs_info) {
400155b8:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
400155bc:	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))
400155c0:	33 03 ff ff 	sethi  %hi(0xffffc00), %i1                     <== NOT EXECUTED
400155c4:	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++)                 
400155c8:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
400155cc:	22 80 00 20 	be,a   4001564c <fat_get_unique_ino+0x94>      <== NOT EXECUTED
400155d0:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
        {                                                             
            if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino)) 
400155d4:	c6 06 20 74 	ld  [ %i0 + 0x74 ], %g3                        <== NOT EXECUTED
400155d8:	c2 06 20 78 	ld  [ %i0 + 0x78 ], %g1                        <== NOT EXECUTED
400155dc:	85 30 60 03 	srl  %g1, 3, %g2                               <== NOT EXECUTED
400155e0:	c8 48 c0 02 	ldsb  [ %g3 + %g2 ], %g4                       <== NOT EXECUTED
400155e4:	b8 08 60 07 	and  %g1, 7, %i4                               <== NOT EXECUTED
400155e8:	b4 00 c0 02 	add  %g3, %g2, %i2                             <== NOT EXECUTED
400155ec:	89 39 00 1c 	sra  %g4, %i4, %g4                             <== NOT EXECUTED
400155f0:	80 89 20 01 	btst  1, %g4                                   <== NOT EXECUTED
400155f4:	02 80 00 1d 	be  40015668 <fat_get_unique_ino+0xb0>         <== NOT EXECUTED
400155f8:	c4 08 c0 02 	ldub  [ %g3 + %g2 ], %g2                       <== NOT EXECUTED
400155fc:	10 80 00 0a 	b  40015624 <fat_get_unique_ino+0x6c>          <== NOT EXECUTED
40015600:	88 10 20 00 	clr  %g4                                       <== NOT EXECUTED
40015604:	85 30 60 03 	srl  %g1, 3, %g2                               <== NOT EXECUTED
40015608:	f6 48 c0 02 	ldsb  [ %g3 + %g2 ], %i3                       <== NOT EXECUTED
4001560c:	b8 08 60 07 	and  %g1, 7, %i4                               <== NOT EXECUTED
40015610:	b4 00 c0 02 	add  %g3, %g2, %i2                             <== NOT EXECUTED
40015614:	b7 3e c0 1c 	sra  %i3, %i4, %i3                             <== NOT EXECUTED
40015618:	80 8e e0 01 	btst  1, %i3                                   <== NOT EXECUTED
4001561c:	02 80 00 13 	be  40015668 <fat_get_unique_ino+0xb0>         <== NOT EXECUTED
40015620:	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++;                                         
40015624:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
            if (fs_info->index >= fs_info->uino_pool_size)            
40015628:	80 a0 40 1d 	cmp  %g1, %i5                                  <== NOT EXECUTED
4001562c:	0a 80 00 03 	bcs  40015638 <fat_get_unique_ino+0x80>        <== NOT EXECUTED
40015630:	c2 26 20 78 	st  %g1, [ %i0 + 0x78 ]                        <== NOT EXECUTED
                fs_info->index = 0;                                   
40015634:	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++)                 
40015638:	88 01 20 01 	inc  %g4                                       <== NOT EXECUTED
4001563c:	80 a1 00 1d 	cmp  %g4, %i5                                  <== NOT EXECUTED
40015640:	32 bf ff f1 	bne,a   40015604 <fat_get_unique_ino+0x4c>     <== NOT EXECUTED
40015644:	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))
40015648:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
4001564c:	93 2f 60 01 	sll  %i5, 1, %o1                               <== NOT EXECUTED
40015650:	82 26 40 01 	sub  %i1, %g1, %g1                             <== NOT EXECUTED
40015654:	80 a2 40 01 	cmp  %o1, %g1                                  <== NOT EXECUTED
40015658:	2a 80 00 0c 	bcs,a   40015688 <fat_get_unique_ino+0xd0>     <== NOT EXECUTED
4001565c:	d0 06 20 74 	ld  [ %i0 + 0x74 ], %o0                        <== NOT EXECUTED
        }                                                             
        else                                                          
            resrc_unsuff = true;                                      
    }                                                                 
    return 0;                                                         
}                                                                     
40015660:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015664:	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); 
40015668:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4001566c:	b9 28 40 1c 	sll  %g1, %i4, %i4                             <== NOT EXECUTED
40015670:	84 17 00 02 	or  %i4, %g2, %g2                              <== NOT EXECUTED
40015674:	c4 2e 80 00 	stb  %g2, [ %i2 ]                              <== NOT EXECUTED
                return (fs_info->uino_base + fs_info->index);         
40015678:	c4 06 20 78 	ld  [ %i0 + 0x78 ], %g2                        <== NOT EXECUTED
4001567c:	c2 06 20 80 	ld  [ %i0 + 0x80 ], %g1                        <== NOT EXECUTED
40015680:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015684:	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);
40015688:	7f ff c5 c6 	call  40006da0 <realloc>                       <== NOT EXECUTED
4001568c:	d2 26 20 7c 	st  %o1, [ %i0 + 0x7c ]                        <== NOT EXECUTED
            if (fs_info->uino != NULL)                                
40015690:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40015694:	02 bf ff f3 	be  40015660 <fat_get_unique_ino+0xa8>         <== NOT EXECUTED
40015698:	d0 26 20 74 	st  %o0, [ %i0 + 0x74 ]                        <== NOT EXECUTED
                fs_info->index = fs_info->uino_pool_size;             
4001569c:	fa 06 20 7c 	ld  [ %i0 + 0x7c ], %i5                        <== NOT EXECUTED
400156a0:	10 bf ff ca 	b  400155c8 <fat_get_unique_ino+0x10>          <== NOT EXECUTED
400156a4:	fa 26 20 78 	st  %i5, [ %i0 + 0x78 ]                        <== NOT EXECUTED
                                                                      

4001553c <fat_init_clusters_chain>: int fat_init_clusters_chain( fat_fs_info_t *fs_info, uint32_t start_cln ) {
4001553c:	9d e3 bf 98 	save  %sp, -104, %sp                           
40015540:	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)      
40015544:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
40015548:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    {                                                                 
        ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
4001554c:	92 10 00 19 	mov  %i1, %o1                                  
40015550:	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)      
40015554:	b2 0e 40 02 	and  %i1, %g2, %i1                             
    {                                                                 
        ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
40015558:	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)      
4001555c:	80 a6 40 01 	cmp  %i1, %g1                                  
40015560:	1a 80 00 10 	bcc  400155a0 <fat_init_clusters_chain+0x64>   
40015564:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
        ret = fat_cluster_set(fs_info, cur_cln, 0, fs_info->vol.bpc, 0);
40015568:	7f ff fc a8 	call  40014808 <fat_cluster_set>               
4001556c:	d6 16 20 06 	lduh  [ %i0 + 6 ], %o3                         
        if ( ret != fs_info->vol.bpc )                                
40015570:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
        {                                                             
            return -1;                                                
        }                                                             
                                                                      
        rc  = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);        
40015574:	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 )                                
40015578:	80 a0 40 08 	cmp  %g1, %o0                                  
4001557c:	12 80 00 0c 	bne  400155ac <fat_init_clusters_chain+0x70>   <== NEVER TAKEN
40015580:	90 10 00 18 	mov  %i0, %o0                                  
        {                                                             
            return -1;                                                
        }                                                             
                                                                      
        rc  = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);        
40015584:	40 00 17 6e 	call  4001b33c <fat_get_fat_cluster>           
40015588:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
        if ( rc != RC_OK )                                            
4001558c:	80 a2 20 00 	cmp  %o0, 0                                    
40015590:	02 bf ff ed 	be  40015544 <fat_init_clusters_chain+0x8>     <== ALWAYS TAKEN
40015594:	f2 07 bf fc 	ld  [ %fp + -4 ], %i1                          
        }                                                             
                                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
40015598:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001559c:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
            return rc;                                                
        }                                                             
                                                                      
    }                                                                 
                                                                      
    return rc;                                                        
400155a0:	90 10 20 00 	clr  %o0                                       
}                                                                     
400155a4:	81 c7 e0 08 	ret                                            
400155a8:	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;                                                
400155ac:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
        }                                                             
                                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
400155b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400155b4:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

40014b10 <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) {
40014b10:	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);                                   
40014b14:	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;                                 
40014b18:	c0 27 bf a4 	clr  [ %fp + -92 ]                             
                                                                      
    vol->fd = open(device, O_RDWR);                                   
40014b1c:	7f ff c8 04 	call  40006b2c <open>                          
40014b20:	90 10 00 19 	mov  %i1, %o0                                  
    if (vol->fd < 0)                                                  
40014b24:	80 a2 20 00 	cmp  %o0, 0                                    
40014b28:	06 80 01 c1 	bl  4001522c <fat_init_volume_info+0x71c>      <== NEVER TAKEN
40014b2c:	d0 26 20 60 	st  %o0, [ %i0 + 0x60 ]                        
    {                                                                 
        rtems_set_errno_and_return_minus_one(ENXIO);                  
    }                                                                 
                                                                      
    rc = fstat(vol->fd, &stat_buf);                                   
40014b30:	7f ff c4 c1 	call  40005e34 <fstat>                         
40014b34:	92 07 bf b8 	add  %fp, -72, %o1                             
    if (rc != 0)                                                      
40014b38:	80 a2 20 00 	cmp  %o0, 0                                    
40014b3c:	12 80 01 b9 	bne  40015220 <fat_init_volume_info+0x710>     <== NEVER TAKEN
40014b40:	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))                                   
40014b44:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
40014b48:	86 08 c0 02 	and  %g3, %g2, %g3                             
40014b4c:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
40014b50:	80 a0 c0 02 	cmp  %g3, %g2                                  
40014b54:	12 80 01 b4 	bne  40015224 <fat_init_volume_info+0x714>     <== NEVER TAKEN
40014b58:	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);                   
40014b5c:	94 06 20 64 	add  %i0, 0x64, %o2                            
40014b60:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
40014b64:	40 00 05 c6 	call  4001627c <ioctl>                         
40014b68:	92 12 62 09 	or  %o1, 0x209, %o1	! 40044209 <__end+0x13d79> 
        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) {                                                    
40014b6c:	80 a2 20 00 	cmp  %o0, 0                                    
40014b70:	12 80 01 ac 	bne  40015220 <fat_init_volume_info+0x710>     <== NEVER TAKEN
40014b74:	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);                       
40014b78:	d0 06 20 64 	ld  [ %i0 + 0x64 ], %o0                        
40014b7c:	7f ff f5 c8 	call  4001229c <rtems_bdbuf_read>              
40014b80:	94 07 bf a4 	add  %fp, -92, %o2                             
    if (sc != RTEMS_SUCCESSFUL)                                       
40014b84:	80 a2 20 00 	cmp  %o0, 0                                    
40014b88:	12 80 01 b5 	bne  4001525c <fat_init_volume_info+0x74c>     <== NEVER TAKEN
40014b8c:	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);               
40014b90:	c4 02 20 1c 	ld  [ %o0 + 0x1c ], %g2                        
40014b94:	c2 08 a0 20 	ldub  [ %g2 + 0x20 ], %g1                      
40014b98:	f8 08 a0 0b 	ldub  [ %g2 + 0xb ], %i4                       
40014b9c:	c2 2f bf 93 	stb  %g1, [ %fp + -109 ]                       
40014ba0:	c2 08 a0 21 	ldub  [ %g2 + 0x21 ], %g1                      
40014ba4:	f6 08 a0 0c 	ldub  [ %g2 + 0xc ], %i3                       
40014ba8:	c2 2f bf 95 	stb  %g1, [ %fp + -107 ]                       
40014bac:	c2 08 a0 22 	ldub  [ %g2 + 0x22 ], %g1                      
40014bb0:	ec 08 a0 0d 	ldub  [ %g2 + 0xd ], %l6                       
40014bb4:	c2 2f bf 94 	stb  %g1, [ %fp + -108 ]                       
40014bb8:	c2 08 a0 23 	ldub  [ %g2 + 0x23 ], %g1                      
40014bbc:	e8 08 a0 0e 	ldub  [ %g2 + 0xe ], %l4                       
40014bc0:	c2 2f bf 8f 	stb  %g1, [ %fp + -113 ]                       
40014bc4:	c2 08 a0 25 	ldub  [ %g2 + 0x25 ], %g1                      
40014bc8:	ea 08 a0 0f 	ldub  [ %g2 + 0xf ], %l5                       
40014bcc:	c2 2f bf 97 	stb  %g1, [ %fp + -105 ]                       
40014bd0:	c2 08 a0 26 	ldub  [ %g2 + 0x26 ], %g1                      
40014bd4:	fa 08 a0 10 	ldub  [ %g2 + 0x10 ], %i5                      
40014bd8:	c2 2f bf 96 	stb  %g1, [ %fp + -106 ]                       
40014bdc:	c2 08 a0 27 	ldub  [ %g2 + 0x27 ], %g1                      
40014be0:	f4 08 a0 11 	ldub  [ %g2 + 0x11 ], %i2                      
40014be4:	c2 2f bf 9f 	stb  %g1, [ %fp + -97 ]                        
40014be8:	c2 08 a0 28 	ldub  [ %g2 + 0x28 ], %g1                      
40014bec:	f2 08 a0 12 	ldub  [ %g2 + 0x12 ], %i1                      
40014bf0:	c2 2f bf 87 	stb  %g1, [ %fp + -121 ]                       
40014bf4:	c2 08 a0 2c 	ldub  [ %g2 + 0x2c ], %g1                      
40014bf8:	e0 08 a0 13 	ldub  [ %g2 + 0x13 ], %l0                      
40014bfc:	c2 2f bf 90 	stb  %g1, [ %fp + -112 ]                       
40014c00:	c2 08 a0 2d 	ldub  [ %g2 + 0x2d ], %g1                      
40014c04:	e2 08 a0 14 	ldub  [ %g2 + 0x14 ], %l1                      
40014c08:	e4 08 a0 16 	ldub  [ %g2 + 0x16 ], %l2                      
40014c0c:	e6 08 a0 17 	ldub  [ %g2 + 0x17 ], %l3                      
40014c10:	ee 08 a0 24 	ldub  [ %g2 + 0x24 ], %l7                      
40014c14:	c2 2f bf 7f 	stb  %g1, [ %fp + -129 ]                       
40014c18:	c2 08 a0 2e 	ldub  [ %g2 + 0x2e ], %g1                      
40014c1c:	c2 2f bf 7e 	stb  %g1, [ %fp + -130 ]                       
40014c20:	c2 08 a0 2f 	ldub  [ %g2 + 0x2f ], %g1                      
40014c24:	c2 2f bf 77 	stb  %g1, [ %fp + -137 ]                       
40014c28:	c2 08 a0 30 	ldub  [ %g2 + 0x30 ], %g1                      
40014c2c:	c4 08 a0 31 	ldub  [ %g2 + 0x31 ], %g2                      
40014c30:	c2 2f bf 92 	stb  %g1, [ %fp + -110 ]                       
                                                                      
    sc = rtems_bdbuf_release( block);                                 
40014c34:	7f ff f6 1f 	call  400124b0 <rtems_bdbuf_release>           
40014c38:	c4 2f bf 91 	stb  %g2, [ %fp + -111 ]                       
    if (sc != RTEMS_SUCCESSFUL)                                       
40014c3c:	80 a2 20 00 	cmp  %o0, 0                                    
40014c40:	12 80 01 87 	bne  4001525c <fat_init_volume_info+0x74c>     <== NEVER TAKEN
40014c44:	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);                 
40014c48:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
40014c4c:	b7 2e e0 08 	sll  %i3, 8, %i3                               
40014c50:	b8 16 c0 1c 	or  %i3, %i4, %i4                              
40014c54:	f8 36 00 00 	sth  %i4, [ %i0 ]                              
                                                                      
    if ( (vol->bps != 512)  &&                                        
40014c58:	93 2f 20 10 	sll  %i4, 0x10, %o1                            
40014c5c:	85 32 60 10 	srl  %o1, 0x10, %g2                            
40014c60:	80 a0 a4 00 	cmp  %g2, 0x400                                
40014c64:	12 80 00 dc 	bne  40014fd4 <fat_init_volume_info+0x4c4>     <== ALWAYS TAKEN
40014c68:	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;
40014c6c:	85 32 60 19 	srl  %o1, 0x19, %g2                            <== NOT EXECUTED
40014c70:	80 88 a0 01 	btst  1, %g2                                   
40014c74:	12 80 00 0a 	bne  40014c9c <fat_init_volume_info+0x18c>     <== ALWAYS TAKEN
40014c78:	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)      
{                                                                     
40014c7c:	10 80 00 03 	b  40014c88 <fat_init_volume_info+0x178>       <== NOT EXECUTED
40014c80:	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;
40014c84:	88 10 00 01 	mov  %g1, %g4                                  <== NOT EXECUTED
         i >>= 1, vol->sec_mul++);                                    
40014c88:	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;
40014c8c:	80 88 a0 01 	btst  1, %g2                                   <== NOT EXECUTED
40014c90:	02 bf ff fd 	be  40014c84 <fat_init_volume_info+0x174>      <== NOT EXECUTED
40014c94:	82 01 20 01 	add  %g4, 1, %g1                               <== NOT EXECUTED
40014c98:	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;               
40014c9c:	c0 2e 20 02 	clrb  [ %i0 + 2 ]                              
40014ca0:	93 32 60 10 	srl  %o1, 0x10, %o1                            
40014ca4:	b6 10 20 01 	mov  1, %i3                                    
40014ca8:	80 8f 20 01 	btst  1, %i4                                   
40014cac:	02 80 00 05 	be  40014cc0 <fat_init_volume_info+0x1b0>      <== ALWAYS TAKEN
40014cb0:	84 10 00 09 	mov  %o1, %g2                                  
40014cb4:	10 80 01 66 	b  4001524c <fat_init_volume_info+0x73c>       <== NOT EXECUTED
40014cb8:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
40014cbc:	b6 10 00 01 	mov  %g1, %i3                                  
         i >>= 1, vol->sec_log2++);                                   
40014cc0:	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;               
40014cc4:	80 88 a0 01 	btst  1, %g2                                   
40014cc8:	02 bf ff fd 	be  40014cbc <fat_init_volume_info+0x1ac>      
40014ccc:	82 06 e0 01 	add  %i3, 1, %g1                               
40014cd0:	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;                                       
40014cd4:	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;                                  
40014cd8:	da 36 20 0a 	sth  %o5, [ %i0 + 0xa ]                        
    vol->bytes_per_block_log2 = vol->sec_log2;                        
40014cdc:	f6 2e 20 0c 	stb  %i3, [ %i0 + 0xc ]                        
    vol->sectors_per_block = 1;                                       
40014ce0:	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)                                                
40014ce4:	b8 8d a0 ff 	andcc  %l6, 0xff, %i4                          
40014ce8:	02 80 01 45 	be  400151fc <fat_init_volume_info+0x6ec>      <== NEVER TAKEN
40014cec:	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;               
40014cf0:	c0 2e 20 05 	clrb  [ %i0 + 5 ]                              
40014cf4:	80 8d a0 01 	btst  1, %l6                                   
40014cf8:	12 80 01 57 	bne  40015254 <fat_init_volume_info+0x744>     
40014cfc:	84 10 00 1c 	mov  %i4, %g2                                  
40014d00:	10 80 00 03 	b  40014d0c <fat_init_volume_info+0x1fc>       
40014d04:	86 10 20 01 	mov  1, %g3                                    
40014d08:	86 10 00 01 	mov  %g1, %g3                                  
         i >>= 1, vol->spc_log2++);                                   
40014d0c:	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;               
40014d10:	80 88 a0 01 	btst  1, %g2                                   
40014d14:	02 bf ff fd 	be  40014d08 <fat_init_volume_info+0x1f8>      
40014d18:	82 00 e0 01 	add  %g3, 1, %g1                               
40014d1c:	c6 2e 20 05 	stb  %g3, [ %i0 + 5 ]                          
40014d20:	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)
40014d24:	87 2a 40 03 	sll  %o1, %g3, %g3                             
40014d28:	89 28 e0 10 	sll  %g3, 0x10, %g4                            
40014d2c:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
40014d30:	80 a1 00 02 	cmp  %g4, %g2                                  
40014d34:	18 80 01 32 	bgu  400151fc <fat_init_volume_info+0x6ec>     <== NEVER TAKEN
40014d38:	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;               
40014d3c:	c0 2e 20 08 	clrb  [ %i0 + 8 ]                              
40014d40:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
40014d44:	88 10 20 01 	mov  1, %g4                                    
40014d48:	84 10 a3 ff 	or  %g2, 0x3ff, %g2                            
40014d4c:	80 88 e0 01 	btst  1, %g3                                   
40014d50:	02 80 00 05 	be  40014d64 <fat_init_volume_info+0x254>      <== ALWAYS TAKEN
40014d54:	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);        
40014d58:	10 80 00 09 	b  40014d7c <fat_init_volume_info+0x26c>       <== NOT EXECUTED
40014d5c:	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;               
40014d60:	88 10 00 01 	mov  %g1, %g4                                  
         i >>= 1, vol->bpc_log2++);                                   
40014d64:	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;               
40014d68:	80 88 a0 01 	btst  1, %g2                                   
40014d6c:	02 bf ff fd 	be  40014d60 <fat_init_volume_info+0x250>      
40014d70:	82 01 20 01 	add  %g4, 1, %g1                               
40014d74:	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);        
40014d78:	b4 0e a0 ff 	and  %i2, 0xff, %i2                            
40014d7c:	b2 0e 60 ff 	and  %i1, 0xff, %i1                            
40014d80:	b3 2e 60 08 	sll  %i1, 8, %i1                               
40014d84:	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)) /
40014d88:	87 2e 60 10 	sll  %i1, 0x10, %g3                            
40014d8c:	87 30 e0 0b 	srl  %g3, 0xb, %g3                             
40014d90:	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);                         
40014d94:	fa 2e 20 0d 	stb  %i5, [ %i0 + 0xd ]                        
    vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);         
40014d98:	aa 0d 60 ff 	and  %l5, 0xff, %l5                            
40014d9c:	a8 0d 20 ff 	and  %l4, 0xff, %l4                            
40014da0:	ab 2d 60 08 	sll  %l5, 8, %l5                               
                                                                      
    vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);        
40014da4:	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);         
40014da8:	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)) /
40014dac:	90 00 c0 08 	add  %g3, %o0, %o0                             
40014db0:	7f ff b6 33 	call  4000267c <.div>                          
40014db4:	e8 36 20 18 	sth  %l4, [ %i0 + 0x18 ]                       
                     vol->bps;                                        
                                                                      
    vol->rdir_size = vol->rdir_secs << vol->sec_log2;                 
40014db8:	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)) /
40014dbc:	d0 26 20 28 	st  %o0, [ %i0 + 0x28 ]                        
40014dc0:	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)                 
40014dc4:	a4 0c a0 ff 	and  %l2, 0xff, %l2                            
40014dc8:	90 0c e0 ff 	and  %l3, 0xff, %o0                            
40014dcc:	91 2a 20 08 	sll  %o0, 8, %o0                               
40014dd0:	90 12 00 12 	or  %o0, %l2, %o0                              
40014dd4:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40014dd8:	80 a2 20 00 	cmp  %o0, 0                                    
40014ddc:	02 80 00 8a 	be  40015004 <fat_init_volume_info+0x4f4>      
40014de0:	f6 26 20 2c 	st  %i3, [ %i0 + 0x2c ]                        
        vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);       
40014de4:	91 32 20 10 	srl  %o0, 0x10, %o0                            
40014de8:	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 +     
40014dec:	92 0f 60 ff 	and  %i5, 0xff, %o1                            
40014df0:	7f ff b5 e7 	call  4000258c <.umul>                         
40014df4:	a9 2d 20 10 	sll  %l4, 0x10, %l4                            
40014df8:	a9 35 20 10 	srl  %l4, 0x10, %l4                            
40014dfc:	90 02 00 14 	add  %o0, %l4, %o0                             
40014e00:	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;       
40014e04:	d0 26 20 20 	st  %o0, [ %i0 + 0x20 ]                        
                                                                      
    if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)             
40014e08:	90 0c 60 ff 	and  %l1, 0xff, %o0                            
40014e0c:	a0 0c 20 ff 	and  %l0, 0xff, %l0                            
40014e10:	91 2a 20 08 	sll  %o0, 8, %o0                               
40014e14:	90 12 00 10 	or  %o0, %l0, %o0                              
40014e18:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40014e1c:	80 a2 20 00 	cmp  %o0, 0                                    
40014e20:	02 80 00 e3 	be  400151ac <fat_init_volume_info+0x69c>      
40014e24:	f4 26 20 34 	st  %i2, [ %i0 + 0x34 ]                        
        vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);     
40014e28:	91 32 20 10 	srl  %o0, 0x10, %o0                            
40014e2c:	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;                             
40014e30:	90 22 00 1a 	sub  %o0, %i2, %o0                             
40014e34:	7f ff b6 10 	call  40002674 <.udiv>                         
40014e38:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
    /* determine FAT type at least */                                 
    if ( vol->data_cls < FAT_FAT12_MAX_CLN)                           
40014e3c:	80 a2 2f f4 	cmp  %o0, 0xff4                                
40014e40:	18 80 00 7d 	bgu  40015034 <fat_init_volume_info+0x524>     
40014e44:	d0 26 20 38 	st  %o0, [ %i0 + 0x38 ]                        
    {                                                                 
        vol->type = FAT_FAT12;                                        
40014e48:	84 10 20 01 	mov  1, %g2                                    
40014e4c:	c4 2e 20 0e 	stb  %g2, [ %i0 + 0xe ]                        
        vol->mask = FAT_FAT12_MASK;                                   
40014e50:	84 10 2f ff 	mov  0xfff, %g2                                
40014e54:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        
        vol->eoc_val = FAT_FAT12_EOC;                                 
40014e58:	84 10 2f f8 	mov  0xff8, %g2                                
40014e5c:	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;                          
40014e60:	84 10 3f ff 	mov  -1, %g2                                   
            }                                                         
        }                                                             
    }                                                                 
    else                                                              
    {                                                                 
        vol->rdir_cl = 0;                                             
40014e64:	c0 26 20 3c 	clr  [ %i0 + 0x3c ]                            
        vol->mirror = 0;                                              
40014e68:	c0 2e 20 54 	clrb  [ %i0 + 0x54 ]                           
        vol->afat = 0;                                                
40014e6c:	c0 2e 20 5c 	clrb  [ %i0 + 0x5c ]                           
        vol->free_cls = FAT_UNDEFINED_VALUE;                          
40014e70:	c4 26 20 44 	st  %g2, [ %i0 + 0x44 ]                        
        vol->next_cl = FAT_UNDEFINED_VALUE;                           
40014e74:	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);                                  
40014e78:	7f ff fd 73 	call  40014444 <fat_buf_release>               
40014e7c:	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;       
40014e80:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
40014e84:	7f ff b5 c2 	call  4000258c <.umul>                         
40014e88:	d0 0e 20 5c 	ldub  [ %i0 + 0x5c ], %o0                      
40014e8c:	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));
40014e90:	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;       
40014e94:	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));
40014e98:	90 10 20 02 	mov  2, %o0                                    
40014e9c:	7f ff c3 85 	call  40005cb0 <calloc>                        
40014ea0:	c4 26 20 58 	st  %g2, [ %i0 + 0x58 ]                        
    if ( fs_info->vhash == NULL )                                     
40014ea4:	80 a2 20 00 	cmp  %o0, 0                                    
40014ea8:	02 80 01 03 	be  400152b4 <fat_init_volume_info+0x7a4>      <== NEVER TAKEN
40014eac:	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 );                        
40014eb0:	88 02 20 04 	add  %o0, 4, %g4                               
40014eb4:	84 02 20 0c 	add  %o0, 0xc, %g2                             
40014eb8:	86 02 20 10 	add  %o0, 0x10, %g3                            
                                                                      
  head->next = tail;                                                  
40014ebc:	c8 22 00 00 	st  %g4, [ %o0 ]                               
  head->previous = NULL;                                              
40014ec0:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
  tail->previous = head;                                              
40014ec4:	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;                                                  
40014ec8:	c6 22 20 0c 	st  %g3, [ %o0 + 0xc ]                         
  head->previous = NULL;                                              
40014ecc:	c0 22 20 10 	clr  [ %o0 + 0x10 ]                            
  tail->previous = head;                                              
40014ed0:	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));
40014ed4:	92 10 20 0c 	mov  0xc, %o1                                  
40014ed8:	7f ff c3 76 	call  40005cb0 <calloc>                        
40014edc:	90 10 20 02 	mov  2, %o0                                    
    if ( fs_info->rhash == NULL )                                     
40014ee0:	80 a2 20 00 	cmp  %o0, 0                                    
40014ee4:	02 80 01 0c 	be  40015314 <fat_init_volume_info+0x804>      <== NEVER TAKEN
40014ee8:	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;        
40014eec:	c4 0e 20 03 	ldub  [ %i0 + 3 ], %g2                         
40014ef0:	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 );                        
40014ef4:	86 02 20 0c 	add  %o0, 0xc, %g3                             
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
40014ef8:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
  tail->previous = head;                                              
40014efc:	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;                                              
40014f00:	c0 22 20 10 	clr  [ %o0 + 0x10 ]                            
  tail->previous = head;                                              
40014f04:	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 );                        
40014f08:	88 02 20 10 	add  %o0, 0x10, %g4                            
40014f0c:	ba 02 20 04 	add  %o0, 4, %i5                               
                                                                      
  head->next = tail;                                                  
40014f10:	c8 22 20 0c 	st  %g4, [ %o0 + 0xc ]                         
40014f14:	fa 22 00 00 	st  %i5, [ %o0 ]                               
40014f18:	85 2f 00 02 	sll  %i4, %g2, %g2                             
40014f1c:	85 28 a0 04 	sll  %g2, 4, %g2                               
40014f20:	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;                
40014f24:	84 10 21 00 	mov  0x100, %g2                                
    fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;        
    fs_info->index = 0;                                               
40014f28:	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;                
40014f2c:	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));
40014f30:	90 10 21 00 	mov  0x100, %o0                                
40014f34:	7f ff c3 5f 	call  40005cb0 <calloc>                        
40014f38:	92 10 20 01 	mov  1, %o1                                    
    if ( fs_info->uino == NULL )                                      
40014f3c:	80 a2 20 00 	cmp  %o0, 0                                    
40014f40:	02 80 00 d0 	be  40015280 <fat_init_volume_info+0x770>      <== NEVER TAKEN
40014f44:	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));  
40014f48:	d0 16 00 00 	lduh  [ %i0 ], %o0                             
40014f4c:	7f ff c3 59 	call  40005cb0 <calloc>                        
40014f50:	92 10 20 01 	mov  1, %o1                                    
    if (fs_info->sec_buf == NULL)                                     
40014f54:	80 a2 20 00 	cmp  %o0, 0                                    
40014f58:	02 80 00 e7 	be  400152f4 <fat_init_volume_info+0x7e4>      <== NEVER TAKEN
40014f5c:	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;                           
40014f60:	c4 0e 20 04 	ldub  [ %i0 + 4 ], %g2                         
40014f64:	c6 06 20 34 	ld  [ %i0 + 0x34 ], %g3                        
40014f68:	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)                       
40014f6c:	80 88 80 03 	btst  %g2, %g3                                 
40014f70:	12 80 00 17 	bne  40014fcc <fat_init_volume_info+0x4bc>     <== NEVER TAKEN
40014f74:	01 00 00 00 	nop                                            
        && (FAT_FAT32 == vol->type || is_cluster_aligned(vol, vol->rdir_loc)))
40014f78:	c6 0e 20 0e 	ldub  [ %i0 + 0xe ], %g3                       
40014f7c:	80 a0 e0 04 	cmp  %g3, 4                                    
40014f80:	22 80 00 07 	be,a   40014f9c <fat_init_volume_info+0x48c>   
40014f84:	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;                           
40014f88:	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)))
40014f8c:	80 88 80 03 	btst  %g2, %g3                                 
40014f90:	12 80 00 0f 	bne  40014fcc <fat_init_volume_info+0x4bc>     <== NEVER TAKEN
40014f94:	01 00 00 00 	nop                                            
    {                                                                 
        sc = rtems_bdbuf_set_block_size (vol->dd, vol->bpc, true);    
40014f98:	d0 06 20 64 	ld  [ %i0 + 0x64 ], %o0                        
40014f9c:	d2 16 20 06 	lduh  [ %i0 + 6 ], %o1                         
40014fa0:	7f ff f6 83 	call  400129ac <rtems_bdbuf_set_block_size>    
40014fa4:	94 10 20 01 	mov  1, %o2                                    
        if (sc == RTEMS_SUCCESSFUL)                                   
40014fa8:	80 a2 20 00 	cmp  %o0, 0                                    
40014fac:	12 80 00 08 	bne  40014fcc <fat_init_volume_info+0x4bc>     <== NEVER TAKEN
40014fb0:	01 00 00 00 	nop                                            
        {                                                             
            vol->bytes_per_block = vol->bpc;                          
40014fb4:	c8 16 20 06 	lduh  [ %i0 + 6 ], %g4                         
            vol->bytes_per_block_log2 = vol->bpc_log2;                
40014fb8:	c6 0e 20 08 	ldub  [ %i0 + 8 ], %g3                         
            vol->sectors_per_block = vol->spc;                        
40014fbc:	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;                          
40014fc0:	c8 36 20 0a 	sth  %g4, [ %i0 + 0xa ]                        
            vol->bytes_per_block_log2 = vol->bpc_log2;                
40014fc4:	c6 2e 20 0c 	stb  %g3, [ %i0 + 0xc ]                        
            vol->sectors_per_block = vol->spc;                        
40014fc8:	c4 2e 20 09 	stb  %g2, [ %i0 + 9 ]                          
        }                                                             
    }                                                                 
                                                                      
    return RC_OK;                                                     
40014fcc:	81 c7 e0 08 	ret                                            
40014fd0:	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)  &&                                        
40014fd4:	80 a0 a2 00 	cmp  %g2, 0x200                                
40014fd8:	22 bf ff 26 	be,a   40014c70 <fat_init_volume_info+0x160>   <== ALWAYS TAKEN
40014fdc:	85 32 60 19 	srl  %o1, 0x19, %g2                            
         (vol->bps != 1024) &&                                        
40014fe0:	80 a0 a8 00 	cmp  %g2, 0x800                                <== NOT EXECUTED
40014fe4:	22 bf ff 26 	be,a   40014c7c <fat_init_volume_info+0x16c>   <== NOT EXECUTED
40014fe8:	85 32 60 19 	srl  %o1, 0x19, %g2                            <== NOT EXECUTED
         (vol->bps != 2048) &&                                        
40014fec:	09 00 00 04 	sethi  %hi(0x1000), %g4                        <== NOT EXECUTED
40014ff0:	80 a0 80 04 	cmp  %g2, %g4                                  <== NOT EXECUTED
40014ff4:	12 80 00 82 	bne  400151fc <fat_init_volume_info+0x6ec>     <== NOT EXECUTED
40014ff8:	85 32 60 19 	srl  %o1, 0x19, %g2                            <== NOT EXECUTED
40014ffc:	10 bf ff 23 	b  40014c88 <fat_init_volume_info+0x178>       <== NOT EXECUTED
40015000:	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);     
40015004:	c4 0f bf 96 	ldub  [ %fp + -106 ], %g2                      
40015008:	d0 0f bf 97 	ldub  [ %fp + -105 ], %o0                      
4001500c:	c2 0f bf 9f 	ldub  [ %fp + -97 ], %g1                       
40015010:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40015014:	91 2a 20 08 	sll  %o0, 8, %o0                               
40015018:	ae 0d e0 ff 	and  %l7, 0xff, %l7                            
4001501c:	90 12 00 02 	or  %o0, %g2, %o0                              
40015020:	85 28 60 18 	sll  %g1, 0x18, %g2                            
40015024:	90 12 00 17 	or  %o0, %l7, %o0                              
40015028:	90 12 00 02 	or  %o0, %g2, %o0                              
4001502c:	10 bf ff 70 	b  40014dec <fat_init_volume_info+0x2dc>       
40015030:	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)                       
40015034:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
40015038:	86 10 a3 f4 	or  %g2, 0x3f4, %g3	! fff4 <PROM_START+0xfff4> 
4001503c:	80 a2 00 03 	cmp  %o0, %g3                                  
40015040:	08 80 00 67 	bleu  400151dc <fat_init_volume_info+0x6cc>    
40015044:	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;
40015048:	c2 0f bf 87 	ldub  [ %fp + -121 ], %g1                      
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
4001504c:	f8 0f bf 7f 	ldub  [ %fp + -129 ], %i4                      
                                                                      
        vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
40015050:	84 08 7f 80 	and  %g1, -128, %g2                            
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40015054:	f6 0f bf 90 	ldub  [ %fp + -112 ], %i3                      
40015058:	c8 0f bf 7e 	ldub  [ %fp + -130 ], %g4                      
4001505c:	c2 0f bf 77 	ldub  [ %fp + -137 ], %g1                      
40015060:	b9 2f 20 08 	sll  %i4, 8, %i4                               
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
            vol->mask = FAT_FAT32_MASK;                               
40015064:	07 03 ff ff 	sethi  %hi(0xffffc00), %g3                     
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40015068:	89 29 20 10 	sll  %g4, 0x10, %g4                            
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
            vol->mask = FAT_FAT32_MASK;                               
4001506c:	ba 10 e3 ff 	or  %g3, 0x3ff, %i5                            
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40015070:	88 17 00 04 	or  %i4, %g4, %g4                              
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
            vol->mask = FAT_FAT32_MASK;                               
            vol->eoc_val = FAT_FAT32_EOC;                             
40015074:	86 10 e3 f8 	or  %g3, 0x3f8, %g3                            
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40015078:	88 11 00 1b 	or  %g4, %i3, %g4                              
4001507c:	b9 28 60 18 	sll  %g1, 0x18, %i4                            
            vol->mask = FAT_FAT16_MASK;                               
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
40015080:	b6 10 20 04 	mov  4, %i3                                    
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40015084:	88 11 00 1c 	or  %g4, %i4, %g4                              
            vol->mask = FAT_FAT16_MASK;                               
            vol->eoc_val = FAT_FAT16_EOC;                             
        }                                                             
        else                                                          
        {                                                             
            vol->type = FAT_FAT32;                                    
40015088:	f6 2e 20 0e 	stb  %i3, [ %i0 + 0xe ]                        
            vol->mask = FAT_FAT32_MASK;                               
4001508c:	fa 26 20 10 	st  %i5, [ %i0 + 0x10 ]                        
            vol->eoc_val = FAT_FAT32_EOC;                             
40015090:	c6 26 20 14 	st  %g3, [ %i0 + 0x14 ]                        
        }                                                             
    }                                                                 
                                                                      
    if (vol->type == FAT_FAT32)                                       
    {                                                                 
        vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);       
40015094:	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)                                              
40015098:	80 88 a0 80 	btst  0x80, %g2                                
4001509c:	02 80 00 6a 	be  40015244 <fat_init_volume_info+0x734>      <== ALWAYS TAKEN
400150a0:	c4 2e 20 54 	stb  %g2, [ %i0 + 0x54 ]                       
            vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
400150a4:	c2 0f bf 87 	ldub  [ %fp + -121 ], %g1                      <== NOT EXECUTED
400150a8:	84 08 60 0f 	and  %g1, 0xf, %g2                             <== NOT EXECUTED
400150ac:	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);    
400150b0:	c4 0f bf 91 	ldub  [ %fp + -111 ], %g2                      
400150b4:	c6 0f bf 92 	ldub  [ %fp + -110 ], %g3                      
400150b8:	85 28 a0 08 	sll  %g2, 8, %g2                               
400150bc:	84 10 80 03 	or  %g2, %g3, %g2                              
400150c0:	c4 36 20 40 	sth  %g2, [ %i0 + 0x40 ]                       
        if( vol->info_sec == 0 )                                      
400150c4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
400150c8:	93 30 a0 10 	srl  %g2, 0x10, %o1                            
400150cc:	80 a2 60 00 	cmp  %o1, 0                                    
400150d0:	02 80 00 4b 	be  400151fc <fat_init_volume_info+0x6ec>      <== NEVER TAKEN
400150d4:	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,         
400150d8:	94 10 20 00 	clr  %o2                                       
400150dc:	96 10 20 04 	mov  4, %o3                                    
400150e0:	7f ff fd 7e 	call  400146d8 <_fat_block_read>               
400150e4:	98 07 bf a8 	add  %fp, -88, %o4                             
                                  FAT_FSI_LEADSIG_SIZE, fs_info_sector);
            if ( ret < 0 )                                            
400150e8:	80 a2 20 00 	cmp  %o0, 0                                    
400150ec:	06 80 00 7d 	bl  400152e0 <fat_init_volume_info+0x7d0>      <== NEVER TAKEN
400150f0:	c4 0f bf ab 	ldub  [ %fp + -85 ], %g2                       
            {                                                         
                close(vol->fd);                                       
                return -1;                                            
            }                                                         
                                                                      
            if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=      
400150f4:	c6 0f bf a9 	ldub  [ %fp + -87 ], %g3                       
400150f8:	fa 0f bf aa 	ldub  [ %fp + -86 ], %i5                       
400150fc:	c8 0f bf a8 	ldub  [ %fp + -88 ], %g4                       
40015100:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40015104:	87 28 e0 08 	sll  %g3, 8, %g3                               
40015108:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
4001510c:	86 10 c0 1d 	or  %g3, %i5, %g3                              
40015110:	86 10 c0 04 	or  %g3, %g4, %g3                              
40015114:	86 10 c0 02 	or  %g3, %g2, %g3                              
40015118:	05 10 58 54 	sethi  %hi(0x41615000), %g2                    
4001511c:	84 10 a2 52 	or  %g2, 0x252, %g2	! 41615252 <RAM_END+0x1215252>
40015120:	80 a0 c0 02 	cmp  %g3, %g2                                  
40015124:	12 80 00 34 	bne  400151f4 <fat_init_volume_info+0x6e4>     <== NEVER TAKEN
40015128:	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,
4001512c:	d2 16 20 40 	lduh  [ %i0 + 0x40 ], %o1                      
40015130:	94 10 21 e4 	mov  0x1e4, %o2                                
40015134:	96 10 20 0c 	mov  0xc, %o3                                  
40015138:	7f ff fd 68 	call  400146d8 <_fat_block_read>               
4001513c:	98 07 bf a8 	add  %fp, -88, %o4                             
                                      FAT_USEFUL_INFO_SIZE, fs_info_sector);
                if ( ret < 0 )                                        
40015140:	80 a2 20 00 	cmp  %o0, 0                                    
40015144:	06 80 00 65 	bl  400152d8 <fat_init_volume_info+0x7c8>      <== NEVER TAKEN
40015148:	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);  
4001514c:	f2 0f bf ae 	ldub  [ %fp + -82 ], %i1                       
40015150:	f4 0f bf ac 	ldub  [ %fp + -84 ], %i2                       
40015154:	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);   
40015158:	f8 0f bf b1 	ldub  [ %fp + -79 ], %i4                       
4001515c:	c4 0f bf b2 	ldub  [ %fp + -78 ], %g2                       
40015160:	fa 0f bf b0 	ldub  [ %fp + -80 ], %i5                       
40015164:	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);  
40015168:	87 28 e0 08 	sll  %g3, 8, %g3                               
4001516c:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
40015170:	b7 2e e0 18 	sll  %i3, 0x18, %i3                            
40015174:	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);   
40015178:	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);  
4001517c:	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);   
40015180:	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);  
40015184:	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);   
40015188:	84 17 00 02 	or  %i4, %g2, %g2                              
4001518c:	89 29 20 18 	sll  %g4, 0x18, %g4                            
40015190:	84 10 80 1d 	or  %g2, %i5, %g2                              
                    _fat_block_release(fs_info);                      
                    close(vol->fd);                                   
                    return -1;                                        
                }                                                     
                                                                      
                vol->free_cls_in_fs_info =                            
40015194:	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);   
40015198:	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;             
4001519c:	c6 26 20 44 	st  %g3, [ %i0 + 0x44 ]                        
                vol->next_cl_in_fs_info =                             
400151a0:	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;               
400151a4:	10 bf ff 35 	b  40014e78 <fat_init_volume_info+0x368>       
400151a8:	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);     
400151ac:	c4 0f bf 94 	ldub  [ %fp + -108 ], %g2                      
400151b0:	d0 0f bf 95 	ldub  [ %fp + -107 ], %o0                      
400151b4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
400151b8:	91 2a 20 08 	sll  %o0, 8, %o0                               
400151bc:	c2 0f bf 93 	ldub  [ %fp + -109 ], %g1                      
400151c0:	90 12 00 02 	or  %o0, %g2, %o0                              
400151c4:	c4 0f bf 8f 	ldub  [ %fp + -113 ], %g2                      
400151c8:	90 12 00 01 	or  %o0, %g1, %o0                              
400151cc:	ad 28 a0 18 	sll  %g2, 0x18, %l6                            
400151d0:	90 12 00 16 	or  %o0, %l6, %o0                              
400151d4:	10 bf ff 17 	b  40014e30 <fat_init_volume_info+0x320>       
400151d8:	d0 26 20 30 	st  %o0, [ %i0 + 0x30 ]                        
    }                                                                 
    else                                                              
    {                                                                 
        if ( vol->data_cls < FAT_FAT16_MAX_CLN)                       
        {                                                             
            vol->type = FAT_FAT16;                                    
400151dc:	88 10 20 02 	mov  2, %g4                                    
            vol->mask = FAT_FAT16_MASK;                               
            vol->eoc_val = FAT_FAT16_EOC;                             
400151e0:	84 10 a3 f8 	or  %g2, 0x3f8, %g2                            
    }                                                                 
    else                                                              
    {                                                                 
        if ( vol->data_cls < FAT_FAT16_MAX_CLN)                       
        {                                                             
            vol->type = FAT_FAT16;                                    
400151e4:	c8 2e 20 0e 	stb  %g4, [ %i0 + 0xe ]                        
            vol->mask = FAT_FAT16_MASK;                               
400151e8:	c6 26 20 10 	st  %g3, [ %i0 + 0x10 ]                        
            vol->eoc_val = FAT_FAT16_EOC;                             
400151ec:	10 bf ff 1d 	b  40014e60 <fat_init_volume_info+0x350>       
400151f0:	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);                                  
400151f4:	7f ff fc 94 	call  40014444 <fat_buf_release>               <== NOT EXECUTED
400151f8:	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);                                       
400151fc:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
40015200:	7f ff c2 c1 	call  40005d04 <close>                         <== NOT EXECUTED
40015204:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                rtems_set_errno_and_return_minus_one( EINVAL );       
40015208:	40 00 20 e2 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001520c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40015210:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
40015214:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40015218:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001521c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = fstat(vol->fd, &stat_buf);                                   
    if (rc != 0)                                                      
    {                                                                 
        close(vol->fd);                                               
40015220:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
40015224:	7f ff c2 b8 	call  40005d04 <close>                         <== NOT EXECUTED
40015228:	01 00 00 00 	nop                                            <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENXIO);                  
4001522c:	40 00 20 d9 	call  4001d590 <__errno>                       <== NOT EXECUTED
40015230:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
40015234:	82 10 20 06 	mov  6, %g1                                    <== NOT EXECUTED
40015238:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001523c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015240:	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;                                            
40015244:	10 bf ff 9b 	b  400150b0 <fat_init_volume_info+0x5a0>       
40015248:	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;                                       
4001524c:	10 bf fe a3 	b  40014cd8 <fat_init_volume_info+0x1c8>       <== NOT EXECUTED
40015250:	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;               
40015254:	10 bf fe b4 	b  40014d24 <fat_init_volume_info+0x214>       
40015258:	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);                                               
4001525c:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
40015260:	7f ff c2 a9 	call  40005d04 <close>                         <== NOT EXECUTED
40015264:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
40015268:	40 00 20 ca 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001526c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40015270:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
40015274:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40015278:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001527c:	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);                                               
40015280:	7f ff c2 a1 	call  40005d04 <close>                         <== NOT EXECUTED
40015284:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
        free(fs_info->vhash);                                         
40015288:	7f ff c2 c1 	call  40005d8c <free>                          <== NOT EXECUTED
4001528c:	d0 06 20 6c 	ld  [ %i0 + 0x6c ], %o0                        <== NOT EXECUTED
        free(fs_info->rhash);                                         
40015290:	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);                                          
40015294:	7f ff c2 be 	call  40005d8c <free>                          <== NOT EXECUTED
40015298:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
4001529c:	40 00 20 bd 	call  4001d590 <__errno>                       <== NOT EXECUTED
400152a0:	01 00 00 00 	nop                                            <== NOT EXECUTED
400152a4:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
400152a8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400152ac:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400152b0:	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);                                               
400152b4:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
400152b8:	7f ff c2 93 	call  40005d04 <close>                         <== NOT EXECUTED
400152bc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( ENOMEM );               
400152c0:	40 00 20 b4 	call  4001d590 <__errno>                       <== NOT EXECUTED
400152c4:	01 00 00 00 	nop                                            <== NOT EXECUTED
400152c8:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             <== NOT EXECUTED
400152cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400152d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400152d4:	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);                                  
400152d8:	7f ff fc 5b 	call  40014444 <fat_buf_release>               <== NOT EXECUTED
400152dc:	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);                                   
400152e0:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
400152e4:	7f ff c2 88 	call  40005d04 <close>                         <== NOT EXECUTED
400152e8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400152ec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400152f0:	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);                                               
400152f4:	7f ff c2 84 	call  40005d04 <close>                         <== NOT EXECUTED
400152f8:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
        free(fs_info->vhash);                                         
400152fc:	7f ff c2 a4 	call  40005d8c <free>                          <== NOT EXECUTED
40015300:	d0 06 20 6c 	ld  [ %i0 + 0x6c ], %o0                        <== NOT EXECUTED
        free(fs_info->rhash);                                         
40015304:	7f ff c2 a2 	call  40005d8c <free>                          <== NOT EXECUTED
40015308:	d0 06 20 70 	ld  [ %i0 + 0x70 ], %o0                        <== NOT EXECUTED
        free(fs_info->uino);                                          
4001530c:	10 bf ff e2 	b  40015294 <fat_init_volume_info+0x784>       <== NOT EXECUTED
40015310:	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);                                               
40015314:	7f ff c2 7c 	call  40005d04 <close>                         <== NOT EXECUTED
40015318:	d0 06 20 60 	ld  [ %i0 + 0x60 ], %o0                        <== NOT EXECUTED
        free(fs_info->vhash);                                         
4001531c:	10 bf ff de 	b  40015294 <fat_init_volume_info+0x784>       <== NOT EXECUTED
40015320:	d0 06 20 6c 	ld  [ %i0 + 0x6c ], %o0                        <== NOT EXECUTED
                                                                      

4001b8f4 <fat_scan_fat_for_free_clusters>: uint32_t count, uint32_t *cls_added, uint32_t *last_cl, bool zero_fill ) {
4001b8f4:	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;          
4001b8f8:	e6 06 20 38 	ld  [ %i0 + 0x38 ], %l3                        
    bool                                  zero_fill                   
    )                                                                 
{                                                                     
    int            rc = RC_OK;                                        
    uint32_t       cl4find = 2;                                       
    uint32_t       next_cln = 0;                                      
4001b8fc:	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;                                                   
4001b900:	c0 26 c0 00 	clr  [ %i3 ]                                   
                                                                      
    if (count == 0)                                                   
4001b904:	80 a6 a0 00 	cmp  %i2, 0                                    
4001b908:	02 80 00 49 	be  4001ba2c <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
4001b90c:	a4 10 20 00 	clr  %l2                                       
        return rc;                                                    
                                                                      
    if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)                  
4001b910:	e0 06 20 4c 	ld  [ %i0 + 0x4c ], %l0                        
4001b914:	80 a4 3f ff 	cmp  %l0, -1                                   
4001b918:	22 80 00 02 	be,a   4001b920 <fat_scan_fat_for_free_clusters+0x2c>
4001b91c:	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;          
4001b920:	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)                                          
4001b924:	80 a4 e0 02 	cmp  %l3, 2                                    
4001b928:	08 80 00 4e 	bleu  4001ba60 <fat_scan_fat_for_free_clusters+0x16c><== NEVER TAKEN
4001b92c:	a2 10 20 02 	mov  2, %l1                                    
4001b930:	10 80 00 1a 	b  4001b998 <fat_scan_fat_for_free_clusters+0xa4>
4001b934:	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);
4001b938:	90 10 00 18 	mov  %i0, %o0                                  
4001b93c:	92 10 00 10 	mov  %l0, %o1                                  
4001b940:	7f ff ff 03 	call  4001b54c <fat_set_fat_cluster>           
4001b944:	94 10 3f ff 	mov  -1, %o2                                   
                if ( rc != RC_OK )                                    
4001b948:	80 a2 20 00 	cmp  %o0, 0                                    
4001b94c:	32 80 00 38 	bne,a   4001ba2c <fat_scan_fat_for_free_clusters+0x138><== NEVER TAKEN
4001b950:	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)                                            
4001b954:	80 a7 60 00 	cmp  %i5, 0                                    
4001b958:	32 80 00 37 	bne,a   4001ba34 <fat_scan_fat_for_free_clusters+0x140>
4001b95c:	d6 16 20 06 	lduh  [ %i0 + 6 ], %o3                         
                    goto cleanup;                                     
                }                                                     
            }                                                         
                                                                      
            save_cln = cl4find;                                       
            (*cls_added)++;                                           
4001b960:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4001b964:	82 00 60 01 	inc  %g1                                       
                                                                      
            /* have we satisfied request ? */                         
            if (*cls_added == count)                                  
4001b968:	80 a6 80 01 	cmp  %i2, %g1                                  
4001b96c:	02 80 00 53 	be  4001bab8 <fat_scan_fat_for_free_clusters+0x1c4>
4001b970:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
4001b974:	a8 10 00 10 	mov  %l0, %l4                                  
                fat_buf_release(fs_info);                             
                return rc;                                            
            }                                                         
        }                                                             
        i++;                                                          
        cl4find++;                                                    
4001b978:	a0 04 20 01 	inc  %l0                                       
        if (cl4find >= data_cls_val)                                  
4001b97c:	80 a4 c0 10 	cmp  %l3, %l0                                  
4001b980:	18 80 00 03 	bgu  4001b98c <fat_scan_fat_for_free_clusters+0x98><== ALWAYS TAKEN
4001b984:	a2 04 60 01 	inc  %l1                                       
            cl4find = 2;                                              
4001b988:	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)                                          
4001b98c:	80 a4 c0 11 	cmp  %l3, %l1                                  
4001b990:	22 80 00 36 	be,a   4001ba68 <fat_scan_fat_for_free_clusters+0x174><== NEVER TAKEN
4001b994:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        <== NOT EXECUTED
    {                                                                 
        rc = fat_get_fat_cluster(fs_info, cl4find, &next_cln);        
4001b998:	90 10 00 18 	mov  %i0, %o0                                  
4001b99c:	92 10 00 10 	mov  %l0, %o1                                  
4001b9a0:	7f ff fe 67 	call  4001b33c <fat_get_fat_cluster>           
4001b9a4:	94 07 bf fc 	add  %fp, -4, %o2                              
        if ( rc != RC_OK )                                            
4001b9a8:	a4 92 20 00 	orcc  %o0, 0, %l2                              
4001b9ac:	12 80 00 3b 	bne  4001ba98 <fat_scan_fat_for_free_clusters+0x1a4><== NEVER TAKEN
4001b9b0:	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)                              
4001b9b4:	80 a0 60 00 	cmp  %g1, 0                                    
4001b9b8:	32 bf ff f1 	bne,a   4001b97c <fat_scan_fat_for_free_clusters+0x88>
4001b9bc:	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)                                      
4001b9c0:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4001b9c4:	80 a0 60 00 	cmp  %g1, 0                                    
4001b9c8:	22 bf ff dc 	be,a   4001b938 <fat_scan_fat_for_free_clusters+0x44>
4001b9cc:	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);
4001b9d0:	90 10 00 18 	mov  %i0, %o0                                  
4001b9d4:	92 10 00 10 	mov  %l0, %o1                                  
4001b9d8:	7f ff fe dd 	call  4001b54c <fat_set_fat_cluster>           
4001b9dc:	94 10 3f ff 	mov  -1, %o2                                   
                if ( rc != RC_OK )                                    
4001b9e0:	82 92 20 00 	orcc  %o0, 0, %g1                              
4001b9e4:	12 80 00 40 	bne  4001bae4 <fat_scan_fat_for_free_clusters+0x1f0><== NEVER TAKEN
4001b9e8:	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); 
4001b9ec:	90 10 00 18 	mov  %i0, %o0                                  
4001b9f0:	7f ff fe d7 	call  4001b54c <fat_set_fat_cluster>           
4001b9f4:	94 10 00 10 	mov  %l0, %o2                                  
                if ( rc != RC_OK )                                    
4001b9f8:	a8 92 20 00 	orcc  %o0, 0, %l4                              
4001b9fc:	02 bf ff d7 	be  4001b958 <fat_scan_fat_for_free_clusters+0x64><== ALWAYS TAKEN
4001ba00:	80 a7 60 00 	cmp  %i5, 0                                    
    return RC_OK;                                                     
                                                                      
cleanup:                                                              
                                                                      
    /* cleanup activity */                                            
    fat_free_fat_clusters_chain(fs_info, (*chain));                   
4001ba04:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
4001ba08:	7f ff ff 83 	call  4001b814 <fat_free_fat_clusters_chain>   <== NOT EXECUTED
4001ba0c:	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);           
4001ba10:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001ba14:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
4001ba18:	7f ff fe cd 	call  4001b54c <fat_set_fat_cluster>           <== NOT EXECUTED
4001ba1c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
    fat_buf_release(fs_info);                                         
    return rc;                                                        
4001ba20:	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);                                         
4001ba24:	7f ff e2 88 	call  40014444 <fat_buf_release>               <== NOT EXECUTED
4001ba28:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    return rc;                                                        
}                                                                     
4001ba2c:	81 c7 e0 08 	ret                                            
4001ba30:	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);
4001ba34:	90 10 00 18 	mov  %i0, %o0                                  
4001ba38:	92 10 00 10 	mov  %l0, %o1                                  
4001ba3c:	94 10 20 00 	clr  %o2                                       
4001ba40:	7f ff e3 72 	call  40014808 <fat_cluster_set>               
4001ba44:	98 10 20 00 	clr  %o4                                       
                if (fs_info->vol.bpc != bytes_written)                
4001ba48:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         
4001ba4c:	80 a0 40 08 	cmp  %g1, %o0                                  
4001ba50:	22 bf ff c5 	be,a   4001b964 <fat_scan_fat_for_free_clusters+0x70><== ALWAYS TAKEN
4001ba54:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
                {                                                     
                    rc = -1;                                          
4001ba58:	10 bf ff eb 	b  4001ba04 <fat_scan_fat_for_free_clusters+0x110><== NOT EXECUTED
4001ba5c:	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)                                          
4001ba60:	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)             
4001ba64:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        <== NOT EXECUTED
4001ba68:	80 a0 7f ff 	cmp  %g1, -1                                   <== NOT EXECUTED
4001ba6c:	02 80 00 05 	be  4001ba80 <fat_scan_fat_for_free_clusters+0x18c><== NOT EXECUTED
4001ba70:	e8 26 20 4c 	st  %l4, [ %i0 + 0x4c ]                        <== NOT EXECUTED
            fs_info->vol.free_cls -= (*cls_added);                    
4001ba74:	c4 06 c0 00 	ld  [ %i3 ], %g2                               <== NOT EXECUTED
4001ba78:	82 20 40 02 	sub  %g1, %g2, %g1                             <== NOT EXECUTED
4001ba7c:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
                                                                      
    *last_cl = save_cln;                                              
4001ba80:	e8 27 00 00 	st  %l4, [ %i4 ]                               <== NOT EXECUTED
    fat_buf_release(fs_info);                                         
4001ba84:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001ba88:	7f ff e2 6f 	call  40014444 <fat_buf_release>               <== NOT EXECUTED
4001ba8c:	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;                                                        
}                                                                     
4001ba90:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ba94:	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)                                      
4001ba98:	c2 06 c0 00 	ld  [ %i3 ], %g1                               <== NOT EXECUTED
4001ba9c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001baa0:	02 bf ff e3 	be  4001ba2c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
4001baa4:	01 00 00 00 	nop                                            <== NOT EXECUTED
                fat_free_fat_clusters_chain(fs_info, (*chain));       
4001baa8:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
4001baac:	7f ff ff 5a 	call  4001b814 <fat_free_fat_clusters_chain>   <== NOT EXECUTED
4001bab0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001bab4:	30 bf ff de 	b,a   4001ba2c <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) 
4001bab8:	c2 06 20 44 	ld  [ %i0 + 0x44 ], %g1                        
4001babc:	80 a0 7f ff 	cmp  %g1, -1                                   
4001bac0:	02 80 00 05 	be  4001bad4 <fat_scan_fat_for_free_clusters+0x1e0><== ALWAYS TAKEN
4001bac4:	e0 26 20 4c 	st  %l0, [ %i0 + 0x4c ]                        
                        fs_info->vol.free_cls -= (*cls_added);        
4001bac8:	c4 06 c0 00 	ld  [ %i3 ], %g2                               <== NOT EXECUTED
4001bacc:	82 20 40 02 	sub  %g1, %g2, %g1                             <== NOT EXECUTED
4001bad0:	c2 26 20 44 	st  %g1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
                *last_cl = save_cln;                                  
4001bad4:	e0 27 00 00 	st  %l0, [ %i4 ]                               
                fat_buf_release(fs_info);                             
4001bad8:	7f ff e2 5b 	call  40014444 <fat_buf_release>               
4001badc:	90 10 00 18 	mov  %i0, %o0                                  
4001bae0:	30 bf ff d3 	b,a   4001ba2c <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));   
4001bae4:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
4001bae8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001baec:	7f ff ff 4a 	call  4001b814 <fat_free_fat_clusters_chain>   <== NOT EXECUTED
4001baf0:	a4 10 00 01 	mov  %g1, %l2                                  <== NOT EXECUTED
4001baf4:	30 bf ff ce 	b,a   4001ba2c <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
                                                                      

40014758 <fat_sector_write>: fat_fs_info_t *fs_info, uint32_t start, uint32_t offset, uint32_t count, const void *buff) {
40014758:	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)                                                  
4001475c:	80 a6 e0 00 	cmp  %i3, 0                                    
40014760:	02 80 00 28 	be  40014800 <fat_sector_write+0xa8>           <== NEVER TAKEN
40014764:	a0 10 20 00 	clr  %l0                                       
}                                                                     
                                                                      
static inline void                                                    
fat_buf_mark_modified(fat_fs_info_t *fs_info)                         
{                                                                     
    fs_info->c.modified = true;                                       
40014768:	10 80 00 12 	b  400147b0 <fat_sector_write+0x58>            
4001476c:	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);
40014770:	96 07 bf fc 	add  %fp, -4, %o3                              
40014774:	7f ff ff ab 	call  40014620 <fat_buf_access>                
40014778:	90 10 00 18 	mov  %i0, %o0                                  
        if (rc != RC_OK)                                              
            return -1;                                                
                                                                      
        memcpy((sec_buf + ofs), (buff + cmpltd), c);                  
4001477c:	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)                                              
40014780:	80 a2 20 00 	cmp  %o0, 0                                    
40014784:	12 80 00 1e 	bne  400147fc <fat_sector_write+0xa4>          <== NEVER TAKEN
40014788:	94 10 00 1d 	mov  %i5, %o2                                  
            return -1;                                                
                                                                      
        memcpy((sec_buf + ofs), (buff + cmpltd), c);                  
4001478c:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
                                                                      
        fat_buf_mark_modified(fs_info);                               
                                                                      
        count -= c;                                                   
        cmpltd +=c;                                                   
40014790:	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);                  
40014794:	40 00 26 24 	call  4001e024 <memcpy>                        
40014798:	90 02 00 1a 	add  %o0, %i2, %o0                             
4001479c:	e2 2e 20 88 	stb  %l1, [ %i0 + 0x88 ]                       
                                                                      
        fat_buf_mark_modified(fs_info);                               
                                                                      
        count -= c;                                                   
        cmpltd +=c;                                                   
        sec_num++;                                                    
400147a0:	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)                                                  
400147a4:	b6 a6 c0 1d 	subcc  %i3, %i5, %i3                           
400147a8:	02 80 00 16 	be  40014800 <fat_sector_write+0xa8>           <== ALWAYS TAKEN
400147ac:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
        c = MIN(count, (fs_info->vol.bps - ofs));                     
400147b0:	fa 16 00 00 	lduh  [ %i0 ], %i5                             
400147b4:	ba 27 40 1a 	sub  %i5, %i2, %i5                             
400147b8:	80 a7 40 1b 	cmp  %i5, %i3                                  
400147bc:	08 80 00 03 	bleu  400147c8 <fat_sector_write+0x70>         
400147c0:	92 10 00 19 	mov  %i1, %o1                                  
400147c4:	ba 10 00 1b 	mov  %i3, %i5                                  
                                                                      
        if (c == fs_info->vol.bytes_per_block)                        
400147c8:	c2 16 20 0a 	lduh  [ %i0 + 0xa ], %g1                       
400147cc:	80 a0 40 1d 	cmp  %g1, %i5                                  
400147d0:	12 bf ff e8 	bne  40014770 <fat_sector_write+0x18>          <== ALWAYS TAKEN
400147d4:	94 10 20 01 	mov  1, %o2                                    
            rc = fat_buf_access(fs_info, sec_num, FAT_OP_TYPE_GET, &sec_buf);
400147d8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
400147dc:	94 10 20 02 	mov  2, %o2                                    <== NOT EXECUTED
400147e0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400147e4:	7f ff ff 8f 	call  40014620 <fat_buf_access>                <== NOT EXECUTED
400147e8:	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);                  
400147ec:	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)                                              
400147f0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400147f4:	02 bf ff e6 	be  4001478c <fat_sector_write+0x34>           <== NOT EXECUTED
400147f8:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
            return -1;                                                
400147fc:	a0 10 3f ff 	mov  -1, %l0                                   <== NOT EXECUTED
        cmpltd +=c;                                                   
        sec_num++;                                                    
        ofs = 0;                                                      
    }                                                                 
    return cmpltd;                                                    
}                                                                     
40014800:	81 c7 e0 08 	ret                                            
40014804:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      

4001b54c <fat_set_fat_cluster>: fat_set_fat_cluster( fat_fs_info_t *fs_info, uint32_t cln, uint32_t in_val ) {
4001b54c:	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;                               
4001b550:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
    /* sanity check */                                                
    if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )           
4001b554:	80 a6 60 01 	cmp  %i1, 1                                    
4001b558:	08 80 00 26 	bleu  4001b5f0 <fat_set_fat_cluster+0xa4>      <== NEVER TAKEN
4001b55c:	ba 10 00 18 	mov  %i0, %i5                                  
4001b560:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
4001b564:	82 00 60 01 	inc  %g1                                       
4001b568:	80 a6 40 01 	cmp  %i1, %g1                                  
4001b56c:	18 80 00 21 	bgu  4001b5f0 <fat_set_fat_cluster+0xa4>       <== NEVER TAKEN
4001b570:	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) +
4001b574:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
4001b578:	80 88 60 01 	btst  1, %g1                                   
4001b57c:	12 80 00 23 	bne  4001b608 <fat_set_fat_cluster+0xbc>       
4001b580:	e0 0e 20 02 	ldub  [ %i0 + 2 ], %l0                         
4001b584:	82 08 60 02 	and  %g1, 2, %g1                               
4001b588:	80 88 60 ff 	btst  0xff, %g1                                
4001b58c:	02 80 00 25 	be  4001b620 <fat_set_fat_cluster+0xd4>        
4001b590:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
4001b594:	b9 2e 60 01 	sll  %i1, 1, %i4                               
4001b598:	a1 37 00 10 	srl  %i4, %l0, %l0                             
4001b59c:	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);
4001b5a0:	e2 17 40 00 	lduh  [ %i5 ], %l1                             
                                                                      
    rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &sec_buf);    
4001b5a4:	90 10 00 1d 	mov  %i5, %o0                                  
4001b5a8:	92 10 00 10 	mov  %l0, %o1                                  
4001b5ac:	94 10 20 01 	mov  1, %o2                                    
4001b5b0:	7f ff e4 1c 	call  40014620 <fat_buf_access>                
4001b5b4:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc != RC_OK)                                                  
4001b5b8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001b5bc:	12 80 00 11 	bne  4001b600 <fat_set_fat_cluster+0xb4>       <== NEVER TAKEN
4001b5c0:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
4001b5c4:	f6 0f 60 0e 	ldub  [ %i5 + 0xe ], %i3                       
4001b5c8:	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);
4001b5cc:	a3 34 60 10 	srl  %l1, 0x10, %l1                            
4001b5d0:	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 )                                      
4001b5d4:	02 80 00 17 	be  4001b630 <fat_set_fat_cluster+0xe4>        
4001b5d8:	b8 0f 00 11 	and  %i4, %l1, %i4                             
4001b5dc:	80 a6 e0 04 	cmp  %i3, 4                                    
4001b5e0:	02 80 00 3b 	be  4001b6cc <fat_set_fat_cluster+0x180>       
4001b5e4:	80 a6 e0 01 	cmp  %i3, 1                                    
4001b5e8:	02 80 00 1f 	be  4001b664 <fat_set_fat_cluster+0x118>       <== ALWAYS TAKEN
4001b5ec:	80 8e 60 01 	btst  1, %i1                                   
                                                                      
            fat_buf_mark_modified(fs_info);                           
            break;                                                    
                                                                      
        default:                                                      
            rtems_set_errno_and_return_minus_one(EIO);                
4001b5f0:	40 00 07 e8 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001b5f4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001b5f8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001b5fc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
            break;                                                    
                                                                      
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
4001b600:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b604:	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) +
4001b608:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        
4001b60c:	b9 36 60 01 	srl  %i1, 1, %i4                               
4001b610:	b8 07 00 19 	add  %i4, %i1, %i4                             
4001b614:	a1 37 00 10 	srl  %i4, %l0, %l0                             
4001b618:	10 bf ff e2 	b  4001b5a0 <fat_set_fat_cluster+0x54>         
4001b61c:	a0 04 00 01 	add  %l0, %g1, %l0                             
4001b620:	b9 2e 60 02 	sll  %i1, 2, %i4                               
4001b624:	a1 37 00 10 	srl  %i4, %l0, %l0                             
4001b628:	10 bf ff de 	b  4001b5a0 <fat_set_fat_cluster+0x54>         
4001b62c:	a0 04 00 01 	add  %l0, %g1, %l0                             
            }                                                         
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *((uint16_t   *)(sec_buf + ofs)) =                        
                    (uint16_t  )(CT_LE_W(in_val));                    
4001b630:	83 2e a0 10 	sll  %i2, 0x10, %g1                            
4001b634:	83 30 60 18 	srl  %g1, 0x18, %g1                            
            break;                                                    
                                                                      
    }                                                                 
                                                                      
    return RC_OK;                                                     
}                                                                     
4001b638:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
4001b63c:	84 10 a3 ff 	or  %g2, 0x3ff, %g2	! ffff <PROM_START+0xffff> 
4001b640:	b4 0e 80 02 	and  %i2, %g2, %i2                             
            }                                                         
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *((uint16_t   *)(sec_buf + ofs)) =                        
                    (uint16_t  )(CT_LE_W(in_val));                    
4001b644:	b5 2e a0 08 	sll  %i2, 8, %i2                               
4001b648:	b4 16 80 01 	or  %i2, %g1, %i2                              
                }                                                     
            }                                                         
            break;                                                    
                                                                      
        case FAT_FAT16:                                               
            *((uint16_t   *)(sec_buf + ofs)) =                        
4001b64c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001b650:	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;                                       
4001b654:	82 10 20 01 	mov  1, %g1                                    
4001b658:	c2 2f 60 88 	stb  %g1, [ %i5 + 0x88 ]                       
4001b65c:	81 c7 e0 08 	ret                                            
4001b660:	81 e8 00 00 	restore                                        
        return rc;                                                    
                                                                      
    switch ( fs_info->vol.type )                                      
    {                                                                 
        case FAT_FAT12:                                               
            if ( FAT_CLUSTER_IS_ODD(cln) )                            
4001b664:	02 80 00 30 	be  4001b724 <fat_set_fat_cluster+0x1d8>       
4001b668:	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);    
4001b66c:	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;                             
4001b670:	c6 08 40 1c 	ldub  [ %g1 + %i4 ], %g3                       
4001b674:	86 08 e0 0f 	and  %g3, 0xf, %g3                             
4001b678:	c6 28 40 1c 	stb  %g3, [ %g1 + %i4 ]                        
                                                                      
                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00F0);    
4001b67c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001b680:	c6 08 40 1c 	ldub  [ %g1 + %i4 ], %g3                       
4001b684:	84 10 c0 02 	or  %g3, %g2, %g2                              
4001b688:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
4001b68c:	c2 17 40 00 	lduh  [ %i5 ], %g1                             
4001b690:	82 00 7f ff 	add  %g1, -1, %g1                              
4001b694:	80 a0 40 1c 	cmp  %g1, %i4                                  
4001b698:	02 80 00 3a 	be  4001b780 <fat_set_fat_cluster+0x234>       <== NEVER TAKEN
4001b69c:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       
                                                                      
                     fat_buf_mark_modified(fs_info);                  
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0x00;                     
4001b6a0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001b6a4:	b8 07 20 01 	inc  %i4                                       
4001b6a8:	c0 28 40 1c 	clrb  [ %g1 + %i4 ]                            
                                                                      
                    *(sec_buf + ofs + 1) |= (uint8_t  )((fat16_clv & 0xFF00)>>8);
4001b6ac:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001b6b0:	b5 2e a0 14 	sll  %i2, 0x14, %i2                            
4001b6b4:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
4001b6b8:	b5 36 a0 18 	srl  %i2, 0x18, %i2                            
4001b6bc:	84 10 80 1a 	or  %g2, %i2, %g2                              
4001b6c0:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
4001b6c4:	81 c7 e0 08 	ret                                            
4001b6c8:	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);    
4001b6cc:	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));           
4001b6d0:	03 3c 00 00 	sethi  %hi(0xf0000000), %g1                    
                                                                      
            *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);    
4001b6d4:	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));           
4001b6d8:	82 2e 80 01 	andn  %i2, %g1, %g1                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
4001b6dc:	89 30 60 18 	srl  %g1, 0x18, %g4                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
4001b6e0:	b7 30 60 08 	srl  %g1, 8, %i3                               
                                                                      
            *((uint32_t *)(sec_buf + ofs)) &= CT_LE_L(0xF0000000);    
4001b6e4:	86 08 e0 f0 	and  %g3, 0xf0, %g3                            
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b6e8:	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;                                       
4001b6ec:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b6f0:	b4 16 80 04 	or  %i2, %g4, %i2                              
4001b6f4:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4001b6f8:	89 30 60 10 	srl  %g1, 0x10, %g4                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b6fc:	82 16 80 1b 	or  %i2, %i3, %g1                              
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4001b700:	88 09 20 ff 	and  %g4, 0xff, %g4                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b704:	89 29 20 08 	sll  %g4, 8, %g4                               
4001b708:	82 10 40 04 	or  %g1, %g4, %g1                              
                                                                      
            *((uint32_t *)(sec_buf + ofs)) |= fat32_clv;              
4001b70c:	82 10 40 03 	or  %g1, %g3, %g1                              
4001b710:	c2 20 80 1c 	st  %g1, [ %g2 + %i4 ]                         
4001b714:	82 10 20 01 	mov  1, %g1                                    
4001b718:	c2 2f 60 88 	stb  %g1, [ %i5 + 0x88 ]                       
4001b71c:	81 c7 e0 08 	ret                                            
4001b720:	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;    
4001b724:	b4 0e af ff 	and  %i2, 0xfff, %i2                           
                *(sec_buf + ofs) &= 0x00;                             
4001b728:	c0 28 40 1c 	clrb  [ %g1 + %i4 ]                            
                                                                      
                *(sec_buf + ofs) |= (uint8_t)(fat16_clv & 0x00FF);    
4001b72c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001b730:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
4001b734:	84 10 80 1a 	or  %g2, %i2, %g2                              
4001b738:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                fat_buf_mark_modified(fs_info);                       
                                                                      
                if ( ofs == (fs_info->vol.bps - 1) )                  
4001b73c:	c2 17 40 00 	lduh  [ %i5 ], %g1                             
4001b740:	82 00 7f ff 	add  %g1, -1, %g1                              
4001b744:	80 a0 40 1c 	cmp  %g1, %i4                                  
4001b748:	02 80 00 20 	be  4001b7c8 <fat_set_fat_cluster+0x27c>       <== NEVER TAKEN
4001b74c:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       
                                                                      
                    fat_buf_mark_modified(fs_info);                   
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0xF0;                     
4001b750:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001b754:	b8 07 20 01 	inc  %i4                                       
4001b758:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
                                                                      
                    *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001b75c:	b5 36 a0 08 	srl  %i2, 8, %i2                               
                                                                      
                    fat_buf_mark_modified(fs_info);                   
                }                                                     
                else                                                  
                {                                                     
                    *(sec_buf + ofs + 1) &= 0xF0;                     
4001b760:	84 08 bf f0 	and  %g2, -16, %g2                             
4001b764:	c4 28 40 1c 	stb  %g2, [ %g1 + %i4 ]                        
                                                                      
                    *(sec_buf + ofs+1) |= (uint8_t)((fat16_clv & 0xFF00)>>8);
4001b768:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001b76c:	c4 08 40 1c 	ldub  [ %g1 + %i4 ], %g2                       
4001b770:	b4 10 80 1a 	or  %g2, %i2, %i2                              
4001b774:	f4 28 40 1c 	stb  %i2, [ %g1 + %i4 ]                        
4001b778:	81 c7 e0 08 	ret                                            
4001b77c:	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,
4001b780:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001b784:	92 04 20 01 	add  %l0, 1, %o1                               <== NOT EXECUTED
4001b788:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
4001b78c:	7f ff e3 a5 	call  40014620 <fat_buf_access>                <== NOT EXECUTED
4001b790:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
                                        &sec_buf);                    
                    if (rc != RC_OK)                                  
4001b794:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001b798:	12 bf ff 9a 	bne  4001b600 <fat_set_fat_cluster+0xb4>       <== NOT EXECUTED
4001b79c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
                        return rc;                                    
                                                                      
                     *sec_buf &= 0x00;                                
                                                                      
                     *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);  
4001b7a0:	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;                                
4001b7a4:	c0 28 40 00 	clrb  [ %g1 ]                                  <== NOT EXECUTED
                                                                      
                     *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);  
4001b7a8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
4001b7ac:	87 30 e0 18 	srl  %g3, 0x18, %g3                            <== NOT EXECUTED
4001b7b0:	c4 08 40 00 	ldub  [ %g1 ], %g2                             <== NOT EXECUTED
4001b7b4:	84 10 c0 02 	or  %g3, %g2, %g2                              <== NOT EXECUTED
4001b7b8:	c4 28 40 00 	stb  %g2, [ %g1 ]                              <== NOT EXECUTED
4001b7bc:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       <== NOT EXECUTED
4001b7c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b7c4:	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,
4001b7c8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001b7cc:	92 04 20 01 	add  %l0, 1, %o1                               <== NOT EXECUTED
4001b7d0:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
4001b7d4:	7f ff e3 93 	call  40014620 <fat_buf_access>                <== NOT EXECUTED
4001b7d8:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
                                        &sec_buf);                    
                    if (rc != RC_OK)                                  
4001b7dc:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001b7e0:	12 bf ff 88 	bne  4001b600 <fat_set_fat_cluster+0xb4>       <== NOT EXECUTED
4001b7e4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
                        return rc;                                    
                                                                      
                    *sec_buf &= 0xF0;                                 
                                                                      
                    *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);   
4001b7e8:	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;                                 
4001b7ec:	c4 08 40 00 	ldub  [ %g1 ], %g2                             <== NOT EXECUTED
4001b7f0:	84 08 bf f0 	and  %g2, -16, %g2                             <== NOT EXECUTED
4001b7f4:	c4 28 40 00 	stb  %g2, [ %g1 ]                              <== NOT EXECUTED
                                                                      
                    *sec_buf |= (uint8_t)((fat16_clv & 0xFF00)>>8);   
4001b7f8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
4001b7fc:	c4 08 40 00 	ldub  [ %g1 ], %g2                             <== NOT EXECUTED
4001b800:	84 16 80 02 	or  %i2, %g2, %g2                              <== NOT EXECUTED
4001b804:	c4 28 40 00 	stb  %g2, [ %g1 ]                              <== NOT EXECUTED
4001b808:	f6 2f 60 88 	stb  %i3, [ %i5 + 0x88 ]                       <== NOT EXECUTED
4001b80c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b810:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001544c <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) {
4001544c:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int            rc = RC_OK;                                        
    int            i = 0;                                             
                                                                      
    rc = fat_sync(fs_info);                                           
40015450:	90 10 00 18 	mov  %i0, %o0                                  
40015454:	7f ff ff b4 	call  40015324 <fat_sync>                      
40015458:	b8 10 00 18 	mov  %i0, %i4                                  
    if ( rc != RC_OK )                                                
4001545c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40015460:	32 80 00 35 	bne,a   40015534 <fat_shutdown_drive+0xe8>     <== NEVER TAKEN
40015464:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
        rc = -1;                                                      
40015468:	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;          
4001546c:	fa 07 20 6c 	ld  [ %i4 + 0x6c ], %i5                        
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
40015470:	10 80 00 04 	b  40015480 <fat_shutdown_drive+0x34>          
40015474:	ba 07 40 1b 	add  %i5, %i3, %i5                             
            free(node);                                               
40015478:	7f ff c2 45 	call  40005d8c <free>                          
4001547c:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
40015480:	7f ff d7 3a 	call  4000b168 <_Chain_Get>                    
40015484:	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 )         
40015488:	80 a2 20 00 	cmp  %o0, 0                                    
4001548c:	12 bf ff fb 	bne  40015478 <fat_shutdown_drive+0x2c>        
40015490:	01 00 00 00 	nop                                            
40015494:	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++)                               
40015498:	80 a6 e0 18 	cmp  %i3, 0x18                                 
4001549c:	32 bf ff f5 	bne,a   40015470 <fat_shutdown_drive+0x24>     
400154a0:	fa 07 20 6c 	ld  [ %i4 + 0x6c ], %i5                        
400154a4:	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;          
400154a8:	fa 07 20 70 	ld  [ %i4 + 0x70 ], %i5                        
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
400154ac:	10 80 00 04 	b  400154bc <fat_shutdown_drive+0x70>          
400154b0:	ba 07 40 1b 	add  %i5, %i3, %i5                             
            free(node);                                               
400154b4:	7f ff c2 36 	call  40005d8c <free>                          <== NOT EXECUTED
400154b8:	01 00 00 00 	nop                                            <== NOT EXECUTED
400154bc:	7f ff d7 2b 	call  4000b168 <_Chain_Get>                    
400154c0:	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 )         
400154c4:	80 a2 20 00 	cmp  %o0, 0                                    
400154c8:	12 bf ff fb 	bne  400154b4 <fat_shutdown_drive+0x68>        <== NEVER TAKEN
400154cc:	01 00 00 00 	nop                                            
400154d0:	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++)                               
400154d4:	80 a6 e0 18 	cmp  %i3, 0x18                                 
400154d8:	32 bf ff f5 	bne,a   400154ac <fat_shutdown_drive+0x60>     
400154dc:	fa 07 20 70 	ld  [ %i4 + 0x70 ], %i5                        
                                                                      
        while ( (node = rtems_chain_get(the_chain)) != NULL )         
            free(node);                                               
    }                                                                 
                                                                      
    free(fs_info->vhash);                                             
400154e0:	7f ff c2 2b 	call  40005d8c <free>                          
400154e4:	d0 07 20 6c 	ld  [ %i4 + 0x6c ], %o0                        
    free(fs_info->rhash);                                             
400154e8:	7f ff c2 29 	call  40005d8c <free>                          
400154ec:	d0 07 20 70 	ld  [ %i4 + 0x70 ], %o0                        
                                                                      
    free(fs_info->uino);                                              
400154f0:	7f ff c2 27 	call  40005d8c <free>                          
400154f4:	d0 07 20 74 	ld  [ %i4 + 0x74 ], %o0                        
    free(fs_info->sec_buf);                                           
400154f8:	7f ff c2 25 	call  40005d8c <free>                          
400154fc:	d0 07 20 90 	ld  [ %i4 + 0x90 ], %o0                        
    close(fs_info->vol.fd);                                           
40015500:	7f ff c2 01 	call  40005d04 <close>                         
40015504:	d0 07 20 60 	ld  [ %i4 + 0x60 ], %o0                        
                                                                      
    if (rc)                                                           
40015508:	80 a6 20 00 	cmp  %i0, 0                                    
4001550c:	12 80 00 04 	bne  4001551c <fat_shutdown_drive+0xd0>        <== NEVER TAKEN
40015510:	01 00 00 00 	nop                                            
        errno = EIO;                                                  
    return rc;                                                        
}                                                                     
40015514:	81 c7 e0 08 	ret                                            
40015518:	81 e8 00 00 	restore                                        
    free(fs_info->uino);                                              
    free(fs_info->sec_buf);                                           
    close(fs_info->vol.fd);                                           
                                                                      
    if (rc)                                                           
        errno = EIO;                                                  
4001551c:	40 00 20 1d 	call  4001d590 <__errno>                       <== NOT EXECUTED
40015520:	01 00 00 00 	nop                                            <== NOT EXECUTED
40015524:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
40015528:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    return rc;                                                        
}                                                                     
4001552c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015530:	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;                                                      
40015534:	10 bf ff ce 	b  4001546c <fat_shutdown_drive+0x20>          <== NOT EXECUTED
40015538:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
                                                                      

40015324 <fat_sync>: return RC_OK; } int fat_sync(fat_fs_info_t *fs_info) {
40015324:	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)                               
40015328:	c2 0e 20 0e 	ldub  [ %i0 + 0xe ], %g1                       
4001532c:	80 a0 60 04 	cmp  %g1, 4                                    
40015330:	02 80 00 0c 	be  40015360 <fat_sync+0x3c>                   
40015334:	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)             
40015338:	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);                                         
4001533c:	7f ff fc 42 	call  40014444 <fat_buf_release>               
40015340:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)     
40015344:	7f ff f5 05 	call  40012758 <rtems_bdbuf_syncdev>           
40015348:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
4001534c:	80 a2 20 00 	cmp  %o0, 0                                    
40015350:	12 80 00 3d 	bne  40015444 <fat_sync+0x120>                 <== NEVER TAKEN
40015354:	01 00 00 00 	nop                                            
        rc = -1;                                                      
                                                                      
    return rc;                                                        
}                                                                     
40015358:	81 c7 e0 08 	ret                                            
4001535c:	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;                  
40015360:	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)           
40015364:	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;                    
40015368:	f8 06 20 4c 	ld  [ %i0 + 0x4c ], %i4                        
                                                                      
        if (free_count != fs_info->vol.free_cls_in_fs_info)           
4001536c:	80 a0 40 02 	cmp  %g1, %g2                                  
40015370:	02 80 00 16 	be  400153c8 <fat_sync+0xa4>                   <== ALWAYS TAKEN
40015374:	b6 10 20 00 	clr  %i3                                       
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
40015378:	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,                          
4001537c:	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;     
40015380:	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;                                       
40015384:	89 30 60 08 	srl  %g1, 8, %g4                               <== NOT EXECUTED
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40015388:	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;            
4001538c:	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;                                       
40015390:	85 30 60 10 	srl  %g1, 0x10, %g2                            <== NOT EXECUTED
  byte2 = (value >> 8)  & 0xff;                                       
40015394:	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;                                       
40015398:	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;     
4001539c:	89 29 20 10 	sll  %g4, 0x10, %g4                            <== NOT EXECUTED
400153a0:	85 28 a0 08 	sll  %g2, 8, %g2                               <== NOT EXECUTED
400153a4:	86 10 c0 04 	or  %g3, %g4, %g3                              <== NOT EXECUTED
400153a8:	82 10 c0 02 	or  %g3, %g2, %g1                              <== NOT EXECUTED
                                                                      
            ret1 = fat_sector_write(fs_info,                          
400153ac:	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);             
400153b0:	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,                          
400153b4:	94 10 21 e8 	mov  0x1e8, %o2                                <== NOT EXECUTED
400153b8:	96 10 20 04 	mov  4, %o3                                    <== NOT EXECUTED
400153bc:	7f ff fc e7 	call  40014758 <fat_sector_write>              <== NOT EXECUTED
400153c0:	98 07 bf fc 	add  %fp, -4, %o4                              <== NOT EXECUTED
400153c4:	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)             
400153c8:	c4 07 60 50 	ld  [ %i5 + 0x50 ], %g2                        
400153cc:	80 a7 00 02 	cmp  %i4, %g2                                  
400153d0:	02 80 00 16 	be  40015428 <fat_sync+0x104>                  <== NEVER TAKEN
400153d4:	90 10 20 00 	clr  %o0                                       
400153d8:	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,                          
400153dc:	d2 17 60 40 	lduh  [ %i5 + 0x40 ], %o1                      
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
400153e0:	83 37 20 18 	srl  %i4, 0x18, %g1                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
400153e4:	87 37 20 08 	srl  %i4, 8, %g3                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400153e8:	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;                                       
400153ec:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
400153f0:	85 37 20 10 	srl  %i4, 0x10, %g2                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400153f4:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
400153f8:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
400153fc:	82 10 40 03 	or  %g1, %g3, %g1                              
40015400:	85 28 a0 08 	sll  %g2, 8, %g2                               
40015404:	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;              
40015408:	f8 27 60 50 	st  %i4, [ %i5 + 0x50 ]                        
                                                                      
            ret2 = fat_sector_write(fs_info,                          
4001540c:	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);               
40015410:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
            fs_info->vol.next_cl_in_fs_info = next_free;              
                                                                      
            ret2 = fat_sector_write(fs_info,                          
40015414:	94 10 21 ec 	mov  0x1ec, %o2                                
40015418:	96 10 20 04 	mov  4, %o3                                    
4001541c:	7f ff fc cf 	call  40014758 <fat_sector_write>              
40015420:	98 07 bf fc 	add  %fp, -4, %o4                              
40015424:	91 32 20 1f 	srl  %o0, 0x1f, %o0                            
                                    sizeof(le_next_free),             
                                    &le_next_free);                   
        }                                                             
    }                                                                 
                                                                      
    if ( (ret1 < 0) || (ret2 < 0) )                                   
40015428:	80 8a 20 ff 	btst  0xff, %o0                                
4001542c:	12 80 00 04 	bne  4001543c <fat_sync+0x118>                 <== NEVER TAKEN
40015430:	80 8e e0 ff 	btst  0xff, %i3                                
40015434:	22 bf ff c2 	be,a   4001533c <fat_sync+0x18>                <== ALWAYS TAKEN
40015438:	b0 10 20 00 	clr  %i0                                       
{                                                                     
    int rc = RC_OK;                                                   
                                                                      
    rc = fat_fat32_update_fsinfo_sector(fs_info);                     
    if ( rc != RC_OK )                                                
        rc = -1;                                                      
4001543c:	10 bf ff c0 	b  4001533c <fat_sync+0x18>                    <== NOT EXECUTED
40015440:	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;                                                      
40015444:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015448:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

400380b4 <fchdir>: /** * compatible with SVr4, 4.4BSD and X/OPEN - Change Directory */ int fchdir( int fd ) {
400380b4:	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 );                                         
400380b8:	03 10 01 95 	sethi  %hi(0x40065400), %g1                    <== NOT EXECUTED
400380bc:	c2 00 60 20 	ld  [ %g1 + 0x20 ], %g1	! 40065420 <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;                                                     
400380c0:	c0 27 bf c4 	clr  [ %fp + -60 ]                             <== NOT EXECUTED
  st.st_uid = 0;                                                      
400380c4:	c0 37 bf ca 	clrh  [ %fp + -54 ]                            <== NOT EXECUTED
  st.st_gid = 0;                                                      
                                                                      
  rtems_libio_check_fd( fd );                                         
400380c8:	80 a6 00 01 	cmp  %i0, %g1                                  <== NOT EXECUTED
400380cc:	1a 80 00 3d 	bcc  400381c0 <fchdir+0x10c>                   <== NOT EXECUTED
400380d0:	c0 37 bf cc 	clrh  [ %fp + -52 ]                            <== NOT EXECUTED
  iop = rtems_libio_iop( fd );                                        
400380d4:	03 10 01 a5 	sethi  %hi(0x40069400), %g1                    <== NOT EXECUTED
400380d8:	fa 00 63 00 	ld  [ %g1 + 0x300 ], %i5	! 40069700 <rtems_libio_iops><== NOT EXECUTED
400380dc:	83 2e 20 03 	sll  %i0, 3, %g1                               <== NOT EXECUTED
400380e0:	b1 2e 20 06 	sll  %i0, 6, %i0                               <== NOT EXECUTED
400380e4:	b0 26 00 01 	sub  %i0, %g1, %i0                             <== NOT EXECUTED
400380e8:	ba 07 40 18 	add  %i5, %i0, %i5                             <== NOT EXECUTED
  rtems_libio_check_is_open( iop );                                   
400380ec:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
400380f0:	80 88 61 00 	btst  0x100, %g1                               <== NOT EXECUTED
400380f4:	02 80 00 33 	be  400381c0 <fchdir+0x10c>                    <== NOT EXECUTED
400380f8:	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;
400380fc:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40038100:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
40038104:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
40038108:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4003810c:	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 );     
40038110:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        <== NOT EXECUTED
40038114:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40038118:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        <== NOT EXECUTED
4003811c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40038120:	92 07 bf b8 	add  %fp, -72, %o1                             <== NOT EXECUTED
  if ( rv == 0 ) {                                                    
40038124:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
40038128:	02 80 00 09 	be  4003814c <fchdir+0x98>                     <== NOT EXECUTED
4003812c:	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;
40038130:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40038134:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
40038138:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           <== NOT EXECUTED
4003813c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40038140:	01 00 00 00 	nop                                            <== NOT EXECUTED
  if ( rv == 0 ) {                                                    
    rv = rtems_filesystem_chdir( &loc );                              
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40038144:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40038148:	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(                   
4003814c:	d4 17 bf ca 	lduh  [ %fp + -54 ], %o2                       <== NOT EXECUTED
40038150:	d6 17 bf cc 	lduh  [ %fp + -52 ], %o3                       <== NOT EXECUTED
40038154:	7f ff 5d 8e 	call  4000f78c <rtems_filesystem_check_access> <== NOT EXECUTED
40038158:	90 10 20 01 	mov  1, %o0                                    <== NOT EXECUTED
      st.st_mode,                                                     
      st.st_uid,                                                      
      st.st_gid                                                       
    );                                                                
                                                                      
    if ( access_ok ) {                                                
4003815c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40038160:	02 80 00 0d 	be  40038194 <fchdir+0xe0>                     <== NOT EXECUTED
40038164:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
      rtems_filesystem_location_clone( &loc, &iop->pathinfo );        
40038168:	7f ff 5b e4 	call  4000f0f8 <rtems_filesystem_location_clone><== NOT EXECUTED
4003816c:	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;
40038170:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40038174:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
40038178:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           <== NOT EXECUTED
4003817c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40038180:	01 00 00 00 	nop                                            <== NOT EXECUTED
    }                                                                 
  }                                                                   
  rtems_filesystem_instance_unlock( &iop->pathinfo );                 
                                                                      
  if ( rv == 0 ) {                                                    
    rv = rtems_filesystem_chdir( &loc );                              
40038184:	7f ff bd 5c 	call  400276f4 <rtems_filesystem_chdir>        <== NOT EXECUTED
40038188:	90 07 bf a0 	add  %fp, -96, %o0                             <== NOT EXECUTED
4003818c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40038190:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
    );                                                                
                                                                      
    if ( access_ok ) {                                                
      rtems_filesystem_location_clone( &loc, &iop->pathinfo );        
    } else {                                                          
      errno = EACCES;                                                 
40038194:	40 00 11 75 	call  4003c768 <__errno>                       <== NOT EXECUTED
40038198:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4003819c:	82 10 20 0d 	mov  0xd, %g1                                  <== NOT EXECUTED
400381a0:	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;
400381a4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
400381a8:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         <== NOT EXECUTED
400381ac:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           <== NOT EXECUTED
400381b0:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400381b4:	01 00 00 00 	nop                                            <== NOT EXECUTED
  if ( rv == 0 ) {                                                    
    rv = rtems_filesystem_chdir( &loc );                              
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400381b8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400381bc:	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 );                                   
400381c0:	40 00 11 6a 	call  4003c768 <__errno>                       <== NOT EXECUTED
400381c4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400381c8:	82 10 20 09 	mov  9, %g1                                    <== NOT EXECUTED
400381cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400381d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400381d4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
400381d8:	40 03 83 40 	call  40118ed8 <__end+0xae8d8>                 <== NOT EXECUTED
400381dc:	40 03 83 34 	call  40118eac <__end+0xae8ac>                 <== NOT EXECUTED
400381e0:	40 03 83 14 	call  40118e30 <__end+0xae830>                 <== NOT EXECUTED
400381e4:	40 03 82 f4 	call  40118db4 <__end+0xae7b4>                 <== NOT EXECUTED
400381e8:	40 03 82 a0 	call  40118c68 <__end+0xae668>                 <== NOT EXECUTED
400381ec:	40 03 82 88 	call  40118c0c <__end+0xae60c>                 <== NOT EXECUTED
400381f0:	40 03 82 88 	call  40118c10 <__end+0xae610>                 <== NOT EXECUTED
400381f4:	40 03 82 88 	call  40118c14 <__end+0xae614>                 <== NOT EXECUTED
400381f8:	40 03 82 88 	call  40118c18 <__end+0xae618>                 <== NOT EXECUTED
400381fc:	40 03 82 88 	call  40118c1c <__end+0xae61c>                 <== NOT EXECUTED
                                                                      

40027c3c <fchmod>: /** * POSIX 1003.1b 5.6.4 - Change File Modes */ int fchmod( int fd, mode_t mode ) {
40027c3c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv;                                                             
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
40027c40:	03 10 01 95 	sethi  %hi(0x40065400), %g1                    
40027c44:	c2 00 60 20 	ld  [ %g1 + 0x20 ], %g1	! 40065420 <rtems_libio_number_iops>
40027c48:	80 a6 00 01 	cmp  %i0, %g1                                  
40027c4c:	1a 80 00 28 	bcc  40027cec <fchmod+0xb0>                    
40027c50:	03 10 01 a5 	sethi  %hi(0x40069400), %g1                    
  iop = rtems_libio_iop( fd );                                        
40027c54:	fa 00 63 00 	ld  [ %g1 + 0x300 ], %i5	! 40069700 <rtems_libio_iops>
40027c58:	83 2e 20 03 	sll  %i0, 3, %g1                               
40027c5c:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40027c60:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40027c64:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open(iop);                                     
40027c68:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
40027c6c:	80 88 61 00 	btst  0x100, %g1                               
40027c70:	02 80 00 1f 	be  40027cec <fchmod+0xb0>                     
40027c74:	01 00 00 00 	nop                                            
                                                                      
  if (iop->pathinfo.mt_entry->writeable) {                            
40027c78:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
40027c7c:	c2 0a 20 29 	ldub  [ %o0 + 0x29 ], %g1                      
40027c80:	80 a0 60 00 	cmp  %g1, 0                                    
40027c84:	02 80 00 14 	be  40027cd4 <fchmod+0x98>                     <== NEVER TAKEN
40027c88:	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 );                               
40027c8c:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40027c90:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40027c94:	9f c0 40 00 	call  %g1                                      
40027c98:	01 00 00 00 	nop                                            
    rtems_filesystem_instance_lock( &iop->pathinfo );                 
    rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
40027c9c:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40027ca0:	90 07 60 14 	add  %i5, 0x14, %o0                            
40027ca4:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40027ca8:	c2 00 60 20 	ld  [ %g1 + 0x20 ], %g1                        
40027cac:	9f c0 40 00 	call  %g1                                      
40027cb0:	92 10 00 19 	mov  %i1, %o1                                  
40027cb4:	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;
40027cb8:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40027cbc:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40027cc0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40027cc4:	9f c0 40 00 	call  %g1                                      
40027cc8:	01 00 00 00 	nop                                            
40027ccc:	81 c7 e0 08 	ret                                            
40027cd0:	81 e8 00 00 	restore                                        
    rtems_filesystem_instance_unlock( &iop->pathinfo );               
  } else {                                                            
    errno = EROFS;                                                    
40027cd4:	40 00 52 a5 	call  4003c768 <__errno>                       <== NOT EXECUTED
40027cd8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40027cdc:	82 10 20 1e 	mov  0x1e, %g1                                 <== NOT EXECUTED
40027ce0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40027ce4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40027ce8:	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);                                     
40027cec:	40 00 52 9f 	call  4003c768 <__errno>                       
40027cf0:	b0 10 3f ff 	mov  -1, %i0                                   
40027cf4:	82 10 20 09 	mov  9, %g1                                    
40027cf8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40027cfc:	81 c7 e0 08 	ret                                            
40027d00:	81 e8 00 00 	restore                                        
                                                                      

40027d04 <fchown>: /** * POSIX 1003.1b 5.6.5 - Change Owner and Group of a File */ int fchown( int fd, uid_t owner, gid_t group ) {
40027d04:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
40027d08:	03 10 01 95 	sethi  %hi(0x40065400), %g1                    
40027d0c:	c2 00 60 20 	ld  [ %g1 + 0x20 ], %g1	! 40065420 <rtems_libio_number_iops>
40027d10:	80 a6 00 01 	cmp  %i0, %g1                                  
40027d14:	1a 80 00 29 	bcc  40027db8 <fchown+0xb4>                    
40027d18:	03 10 01 a5 	sethi  %hi(0x40069400), %g1                    
  iop = rtems_libio_iop( fd );                                        
40027d1c:	fa 00 63 00 	ld  [ %g1 + 0x300 ], %i5	! 40069700 <rtems_libio_iops>
40027d20:	83 2e 20 03 	sll  %i0, 3, %g1                               
40027d24:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40027d28:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40027d2c:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open(iop);                                     
40027d30:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
40027d34:	80 88 61 00 	btst  0x100, %g1                               
40027d38:	02 80 00 20 	be  40027db8 <fchown+0xb4>                     
40027d3c:	01 00 00 00 	nop                                            
                                                                      
  if (iop->pathinfo.mt_entry->writeable) {                            
40027d40:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
40027d44:	c2 0a 20 29 	ldub  [ %o0 + 0x29 ], %g1                      
40027d48:	80 a0 60 00 	cmp  %g1, 0                                    
40027d4c:	02 80 00 15 	be  40027da0 <fchown+0x9c>                     <== NEVER TAKEN
40027d50:	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 );                               
40027d54:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40027d58:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40027d5c:	9f c0 40 00 	call  %g1                                      
40027d60:	01 00 00 00 	nop                                            
    rtems_filesystem_instance_lock( &iop->pathinfo );                 
    rv = (*iop->pathinfo.mt_entry->ops->chown_h)(                     
40027d64:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40027d68:	90 07 60 14 	add  %i5, 0x14, %o0                            
40027d6c:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40027d70:	92 10 00 19 	mov  %i1, %o1                                  
40027d74:	c2 00 60 24 	ld  [ %g1 + 0x24 ], %g1                        
40027d78:	9f c0 40 00 	call  %g1                                      
40027d7c:	94 10 00 1a 	mov  %i2, %o2                                  
40027d80:	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;
40027d84:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40027d88:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40027d8c:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40027d90:	9f c0 40 00 	call  %g1                                      
40027d94:	01 00 00 00 	nop                                            
40027d98:	81 c7 e0 08 	ret                                            
40027d9c:	81 e8 00 00 	restore                                        
      owner,                                                          
      group                                                           
    );                                                                
    rtems_filesystem_instance_unlock( &iop->pathinfo );               
  } else {                                                            
    errno = EROFS;                                                    
40027da0:	40 00 52 72 	call  4003c768 <__errno>                       <== NOT EXECUTED
40027da4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40027da8:	82 10 20 1e 	mov  0x1e, %g1                                 <== NOT EXECUTED
40027dac:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40027db0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40027db4:	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);                                     
40027db8:	40 00 52 6c 	call  4003c768 <__errno>                       
40027dbc:	b0 10 3f ff 	mov  -1, %i0                                   
40027dc0:	82 10 20 09 	mov  9, %g1                                    
40027dc4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40027dc8:	81 c7 e0 08 	ret                                            
40027dcc:	81 e8 00 00 	restore                                        
                                                                      

4003418c <fcntl>: int fcntl( int fd, int cmd, ... ) {
4003418c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
40034190:	03 10 00 e8 	sethi  %hi(0x4003a000), %g1                    
40034194:	c4 00 63 ac 	ld  [ %g1 + 0x3ac ], %g2	! 4003a3ac <rtems_libio_number_iops>
  ...                                                                 
)                                                                     
{                                                                     
  int            ret;                                                 
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
40034198:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
4003419c:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            
400341a0:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
400341a4:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
400341a8:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
400341ac:	80 a6 00 02 	cmp  %i0, %g2                                  
400341b0:	1a 80 00 7c 	bcc  400343a0 <fcntl+0x214>                    
400341b4:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
  iop = rtems_libio_iop( fd );                                        
400341b8:	39 10 01 2c 	sethi  %hi(0x4004b000), %i4                    
400341bc:	fa 07 20 94 	ld  [ %i4 + 0x94 ], %i5	! 4004b094 <rtems_libio_iops>
400341c0:	85 2e 20 03 	sll  %i0, 3, %g2                               
400341c4:	b1 2e 20 06 	sll  %i0, 6, %i0                               
400341c8:	b0 26 00 02 	sub  %i0, %g2, %i0                             
400341cc:	ba 07 40 18 	add  %i5, %i0, %i5                             
  rtems_libio_check_is_open(iop);                                     
400341d0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
400341d4:	80 8a 21 00 	btst  0x100, %o0                               
400341d8:	02 80 00 72 	be  400343a0 <fcntl+0x214>                     
400341dc:	80 a6 60 09 	cmp  %i1, 9                                    
                                                                      
  /*                                                                  
   *  This switch should contain all the cases from POSIX.            
   */                                                                 
                                                                      
  switch ( cmd ) {                                                    
400341e0:	08 80 00 08 	bleu  40034200 <fcntl+0x74>                    
400341e4:	85 2e 60 02 	sll  %i1, 2, %g2                               
      errno = ENOTSUP;                                                
      ret = -1;                                                       
      break;                                                          
                                                                      
    default:                                                          
      errno = EINVAL;                                                 
400341e8:	7f ff be 54 	call  40023b38 <__errno>                       
400341ec:	b0 10 3f ff 	mov  -1, %i0                                   
400341f0:	82 10 20 16 	mov  0x16, %g1                                 
400341f4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  va_list        ap;                                                  
  va_start( ap, cmd );                                                
  ret = vfcntl(fd,cmd,ap);                                            
  va_end(ap);                                                         
  return ret;                                                         
}                                                                     
400341f8:	81 c7 e0 08 	ret                                            
400341fc:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  This switch should contain all the cases from POSIX.            
   */                                                                 
                                                                      
  switch ( cmd ) {                                                    
40034200:	07 10 00 d0 	sethi  %hi(0x40034000), %g3                    
40034204:	86 10 e1 64 	or  %g3, 0x164, %g3	! 40034164 <_calloc_r+0x14>
40034208:	c4 00 c0 02 	ld  [ %g3 + %g2 ], %g2                         
4003420c:	81 c0 80 00 	jmp  %g2                                       
40034210:	01 00 00 00 	nop                                            
      errno = ENOTSUP;                                                
      ret = -1;                                                       
      break;                                                          
                                                                      
    case F_GETOWN:       /*  for sockets. */                          
      errno = ENOTSUP;                                                
40034214:	7f ff be 49 	call  40023b38 <__errno>                       
40034218:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  
4003421c:	82 10 20 86 	mov  0x86, %g1                                 
40034220:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40034224:	81 c7 e0 08 	ret                                            
40034228:	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 ) );           
4003422c:	d0 00 40 00 	ld  [ %g1 ], %o0                               
40034230:	7f ff 54 95 	call  40009484 <rtems_libio_fcntl_flags>       
40034234:	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);             
40034238:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4003423c:	90 0a 22 01 	and  %o0, 0x201, %o0                           
40034240:	82 08 7d fe 	and  %g1, -514, %g1                            
40034244:	82 12 00 01 	or  %o0, %g1, %g1                              
40034248:	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 );         
4003424c:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
40034250:	90 10 00 1d 	mov  %i5, %o0                                  
40034254:	c2 00 60 28 	ld  [ %g1 + 0x28 ], %g1                        
40034258:	9f c0 40 00 	call  %g1                                      
4003425c:	92 10 00 19 	mov  %i1, %o1                                  
    if (err) {                                                        
40034260:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40034264:	02 80 00 53 	be  400343b0 <fcntl+0x224>                     <== ALWAYS TAKEN
40034268:	01 00 00 00 	nop                                            
      errno = err;                                                    
4003426c:	7f ff be 33 	call  40023b38 <__errno>                       <== NOT EXECUTED
40034270:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
40034274:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
40034278:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4003427c:	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 );                 
40034280:	7f ff 54 8e 	call  400094b8 <rtems_libio_to_fcntl_flags>    
40034284:	01 00 00 00 	nop                                            
40034288:	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) {                                                     
4003428c:	80 a6 20 00 	cmp  %i0, 0                                    
40034290:	36 bf ff f0 	bge,a   40034250 <fcntl+0xc4>                  <== ALWAYS TAKEN
40034294:	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;                                                         
}                                                                     
40034298:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4003429c:	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 ) )                                        
400342a0:	c2 00 40 00 	ld  [ %g1 ], %g1                               
400342a4:	80 a0 60 00 	cmp  %g1, 0                                    
400342a8:	22 80 00 3b 	be,a   40034394 <fcntl+0x208>                  
400342ac:	90 0a 37 ff 	and  %o0, -2049, %o0                           
        iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;                      
400342b0:	90 12 28 00 	or  %o0, 0x800, %o0                            
{                                                                     
  rtems_libio_t *iop;                                                 
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
400342b4:	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;                      
400342b8:	10 bf ff e5 	b  4003424c <fcntl+0xc0>                       
400342bc:	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);          
400342c0:	b1 32 20 0b 	srl  %o0, 0xb, %i0                             
400342c4:	10 bf ff e2 	b  4003424c <fcntl+0xc0>                       
400342c8:	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();                       
400342cc:	7f ff 54 92 	call  40009514 <rtems_libio_allocate>          
400342d0:	01 00 00 00 	nop                                            
                                                                      
  if (diop != NULL) {                                                 
400342d4:	b6 92 20 00 	orcc  %o0, 0, %i3                              
400342d8:	02 bf ff c8 	be  400341f8 <fcntl+0x6c>                      
400342dc:	b0 10 3f ff 	mov  -1, %i0                                   
    int oflag = rtems_libio_to_fcntl_flags( iop->flags );             
400342e0:	7f ff 54 76 	call  400094b8 <rtems_libio_to_fcntl_flags>    
400342e4:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
                                                                      
    oflag &= ~O_CREAT;                                                
    diop->flags |= rtems_libio_fcntl_flags( oflag );                  
400342e8:	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;                                                
400342ec:	b4 0a 3d ff 	and  %o0, -513, %i2                            
    diop->flags |= rtems_libio_fcntl_flags( oflag );                  
400342f0:	7f ff 54 65 	call  40009484 <rtems_libio_fcntl_flags>       
400342f4:	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;
400342f8:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
400342fc:	b0 12 00 18 	or  %o0, %i0, %i0                              
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
40034300:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
40034304:	90 10 00 01 	mov  %g1, %o0                                  
40034308:	c2 00 80 00 	ld  [ %g2 ], %g1                               
4003430c:	9f c0 40 00 	call  %g1                                      
40034310:	f0 26 e0 10 	st  %i0, [ %i3 + 0x10 ]                        
                                                                      
    rtems_filesystem_instance_lock( &iop->pathinfo );                 
    rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
40034314:	92 07 60 14 	add  %i5, 0x14, %o1                            
40034318:	7f ff 91 ac 	call  400189c8 <rtems_filesystem_location_clone>
4003431c:	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;
40034320:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
40034324:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
40034328:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4003432c:	9f c0 40 00 	call  %g1                                      
40034330:	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 );  
40034334:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
40034338:	90 10 00 1b 	mov  %i3, %o0                                  
4003433c:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40034340:	92 10 20 00 	clr  %o1                                       
40034344:	94 10 00 1a 	mov  %i2, %o2                                  
40034348:	9f c0 40 00 	call  %g1                                      
4003434c:	96 10 20 00 	clr  %o3                                       
    if ( rv == 0 ) {                                                  
40034350:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40034354:	12 80 00 19 	bne  400343b8 <fcntl+0x22c>                    <== NEVER TAKEN
40034358:	c2 07 20 94 	ld  [ %i4 + 0x94 ], %g1                        
      rv = diop - rtems_libio_iops;                                   
4003435c:	b6 26 c0 01 	sub  %i3, %g1, %i3                             
40034360:	b7 3e e0 03 	sra  %i3, 3, %i3                               
40034364:	85 2e e0 03 	sll  %i3, 3, %g2                               
40034368:	83 2e e0 06 	sll  %i3, 6, %g1                               
4003436c:	82 00 80 01 	add  %g2, %g1, %g1                             
40034370:	85 28 60 06 	sll  %g1, 6, %g2                               
40034374:	82 00 40 02 	add  %g1, %g2, %g1                             
40034378:	82 00 40 1b 	add  %g1, %i3, %g1                             
4003437c:	85 28 60 0f 	sll  %g1, 0xf, %g2                             
40034380:	82 00 40 02 	add  %g1, %g2, %g1                             
40034384:	83 28 60 03 	sll  %g1, 3, %g1                               
40034388:	b6 00 40 1b 	add  %g1, %i3, %i3                             
4003438c:	10 bf ff c0 	b  4003428c <fcntl+0x100>                      
40034390:	b0 20 00 1b 	neg  %i3, %i0                                  
{                                                                     
  rtems_libio_t *iop;                                                 
  int            fd2;                                                 
  int            flags;                                               
  int            mask;                                                
  int            ret = 0;                                             
40034394:	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;                     
40034398:	10 bf ff ad 	b  4003424c <fcntl+0xc0>                       
4003439c:	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);                                     
400343a0:	7f ff bd e6 	call  40023b38 <__errno>                       
400343a4:	b0 10 3f ff 	mov  -1, %i0                                   
400343a8:	82 10 20 09 	mov  9, %g1                                    
400343ac:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400343b0:	81 c7 e0 08 	ret                                            
400343b4:	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 );                                       
400343b8:	7f ff 54 6d 	call  4000956c <rtems_libio_free>              <== NOT EXECUTED
400343bc:	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) {                                                     
400343c0:	10 bf ff b4 	b  40034290 <fcntl+0x104>                      <== NOT EXECUTED
400343c4:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
                                                                      

40004bec <fdatasync>: #include <rtems/seterr.h> int fdatasync( int fd ) {
40004bec:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
40004bf0:	03 10 00 60 	sethi  %hi(0x40018000), %g1                    
40004bf4:	c2 00 60 c4 	ld  [ %g1 + 0xc4 ], %g1	! 400180c4 <rtems_libio_number_iops>
40004bf8:	80 a6 00 01 	cmp  %i0, %g1                                  
40004bfc:	1a 80 00 13 	bcc  40004c48 <fdatasync+0x5c>                 
40004c00:	03 10 00 63 	sethi  %hi(0x40018c00), %g1                    
  iop = rtems_libio_iop( fd );                                        
40004c04:	d0 00 60 20 	ld  [ %g1 + 0x20 ], %o0	! 40018c20 <rtems_libio_iops>
40004c08:	83 2e 20 03 	sll  %i0, 3, %g1                               
40004c0c:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40004c10:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40004c14:	90 02 00 18 	add  %o0, %i0, %o0                             
  rtems_libio_check_is_open(iop);                                     
40004c18:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
40004c1c:	80 88 61 00 	btst  0x100, %g1                               
40004c20:	02 80 00 0a 	be  40004c48 <fdatasync+0x5c>                  <== NEVER TAKEN
40004c24:	80 88 60 04 	btst  4, %g1                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40004c28:	02 80 00 08 	be  40004c48 <fdatasync+0x5c>                  
40004c2c:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  Now process the fdatasync().                                    
   */                                                                 
                                                                      
  return (*iop->pathinfo.handlers->fdatasync_h)( iop );               
40004c30:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        
40004c34:	c2 00 60 24 	ld  [ %g1 + 0x24 ], %g1                        
40004c38:	9f c0 40 00 	call  %g1                                      
40004c3c:	01 00 00 00 	nop                                            
}                                                                     
40004c40:	81 c7 e0 08 	ret                                            
40004c44:	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 );
40004c48:	40 00 32 5d 	call  400115bc <__errno>                       
40004c4c:	b0 10 3f ff 	mov  -1, %i0                                   
40004c50:	82 10 20 09 	mov  9, %g1                                    
40004c54:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40004c58:	81 c7 e0 08 	ret                                            
40004c5c:	81 e8 00 00 	restore                                        
                                                                      

4000ed00 <fifo_open>: int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) {
4000ed00:	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) {                              
4000ed04:	3b 10 00 92 	sethi  %hi(0x40024800), %i5                    
4000ed08:	d0 07 63 20 	ld  [ %i5 + 0x320 ], %o0	! 40024b20 <pipe_semaphore>
                                                                      
int fifo_open(                                                        
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
4000ed0c:	b6 10 00 18 	mov  %i0, %i3                                  
                                                                      
static int pipe_lock(void)                                            
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
4000ed10:	80 a2 20 00 	cmp  %o0, 0                                    
4000ed14:	02 80 00 18 	be  4000ed74 <fifo_open+0x74>                  
4000ed18:	b8 17 63 20 	or  %i5, 0x320, %i4                            
                                                                      
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
    sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4000ed1c:	92 10 20 00 	clr  %o1                                       
4000ed20:	7f ff eb d9 	call  40009c84 <rtems_semaphore_obtain>        
4000ed24:	94 10 20 00 	clr  %o2                                       
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
4000ed28:	80 a2 20 00 	cmp  %o0, 0                                    
4000ed2c:	12 80 00 7a 	bne  4000ef14 <fifo_open+0x214>                <== NEVER TAKEN
4000ed30:	01 00 00 00 	nop                                            
                                                                      
  err = pipe_lock();                                                  
  if (err)                                                            
    return err;                                                       
                                                                      
  pipe = *pipep;                                                      
4000ed34:	f8 06 c0 00 	ld  [ %i3 ], %i4                               
  if (pipe == NULL) {                                                 
4000ed38:	80 a7 20 00 	cmp  %i4, 0                                    
4000ed3c:	02 80 00 1b 	be  4000eda8 <fifo_open+0xa8>                  
4000ed40:	01 00 00 00 	nop                                            
    err = pipe_alloc(&pipe);                                          
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
4000ed44:	d0 07 20 28 	ld  [ %i4 + 0x28 ], %o0                        
4000ed48:	92 10 20 00 	clr  %o1                                       
4000ed4c:	7f ff eb ce 	call  40009c84 <rtems_semaphore_obtain>        
4000ed50:	94 10 20 00 	clr  %o2                                       
4000ed54:	80 a2 20 00 	cmp  %o0, 0                                    
4000ed58:	02 80 00 8c 	be  4000ef88 <fifo_open+0x288>                 <== ALWAYS TAKEN
4000ed5c:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
    err = -EINTR;                                                     
                                                                      
  if (*pipep == NULL) {                                               
4000ed60:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000ed64:	22 80 00 6e 	be,a   4000ef1c <fifo_open+0x21c>              <== NOT EXECUTED
4000ed68:	d0 07 20 2c 	ld  [ %i4 + 0x2c ], %o0                        <== NOT EXECUTED
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    err = -EINTR;                                                     
4000ed6c:	10 80 00 76 	b  4000ef44 <fifo_open+0x244>                  <== NOT EXECUTED
4000ed70:	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 );
4000ed74:	35 10 00 93 	sethi  %hi(0x40024c00), %i2                    
4000ed78:	d0 06 a2 0c 	ld  [ %i2 + 0x20c ], %o0	! 40024e0c <rtems_libio_semaphore>
4000ed7c:	92 10 20 00 	clr  %o1                                       
4000ed80:	7f ff eb c1 	call  40009c84 <rtems_semaphore_obtain>        
4000ed84:	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) {                            
4000ed88:	c2 07 63 20 	ld  [ %i5 + 0x320 ], %g1                       
4000ed8c:	80 a0 60 00 	cmp  %g1, 0                                    
4000ed90:	02 80 00 55 	be  4000eee4 <fifo_open+0x1e4>                 <== ALWAYS TAKEN
4000ed94:	98 10 00 1c 	mov  %i4, %o4                                  
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
4000ed98:	7f ff ec 0a 	call  40009dc0 <rtems_semaphore_release>       <== NOT EXECUTED
4000ed9c:	d0 06 a2 0c 	ld  [ %i2 + 0x20c ], %o0                       <== NOT EXECUTED
4000eda0:	10 bf ff df 	b  4000ed1c <fifo_open+0x1c>                   <== NOT EXECUTED
4000eda4:	d0 07 63 20 	ld  [ %i5 + 0x320 ], %o0                       <== NOT EXECUTED
{                                                                     
  static char c = 'a';                                                
  pipe_control_t *pipe;                                               
  int err = -ENOMEM;                                                  
                                                                      
  pipe = malloc(sizeof(pipe_control_t));                              
4000eda8:	7f ff da 69 	call  4000574c <malloc>                        
4000edac:	90 10 20 34 	mov  0x34, %o0                                 
  if (pipe == NULL)                                                   
4000edb0:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4000edb4:	02 80 00 73 	be  4000ef80 <fifo_open+0x280>                 <== NEVER TAKEN
4000edb8:	82 10 22 00 	mov  0x200, %g1                                
    return err;                                                       
  memset(pipe, 0, sizeof(pipe_control_t));                            
4000edbc:	c0 27 00 00 	clr  [ %i4 ]                                   
4000edc0:	c0 27 20 08 	clr  [ %i4 + 8 ]                               
4000edc4:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             
4000edc8:	c0 27 20 10 	clr  [ %i4 + 0x10 ]                            
4000edcc:	c0 27 20 14 	clr  [ %i4 + 0x14 ]                            
4000edd0:	c0 27 20 18 	clr  [ %i4 + 0x18 ]                            
4000edd4:	c0 27 20 1c 	clr  [ %i4 + 0x1c ]                            
4000edd8:	c0 27 20 20 	clr  [ %i4 + 0x20 ]                            
4000eddc:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            
4000ede0:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            
4000ede4:	c0 27 20 2c 	clr  [ %i4 + 0x2c ]                            
4000ede8:	c0 27 20 30 	clr  [ %i4 + 0x30 ]                            
                                                                      
  pipe->Size = PIPE_BUF;                                              
  pipe->Buffer = malloc(pipe->Size);                                  
4000edec:	90 10 22 00 	mov  0x200, %o0                                
4000edf0:	7f ff da 57 	call  4000574c <malloc>                        
4000edf4:	c2 27 20 04 	st  %g1, [ %i4 + 4 ]                           
  if (! pipe->Buffer)                                                 
4000edf8:	80 a2 20 00 	cmp  %o0, 0                                    
4000edfc:	02 80 00 5f 	be  4000ef78 <fifo_open+0x278>                 <== NEVER TAKEN
4000ee00:	d0 27 00 00 	st  %o0, [ %i4 ]                               
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
                                                                      
  if (rtems_barrier_create(                                           
        rtems_build_name ('P', 'I', 'r', c),                          
4000ee04:	35 10 00 90 	sethi  %hi(0x40024000), %i2                    
4000ee08:	d0 4e a3 90 	ldsb  [ %i2 + 0x390 ], %o0	! 40024390 <c.7174> 
  if (! pipe->Buffer)                                                 
    goto err_buf;                                                     
                                                                      
  err = -ENOMEM;                                                      
                                                                      
  if (rtems_barrier_create(                                           
4000ee0c:	31 14 12 5c 	sethi  %hi(0x50497000), %i0                    
4000ee10:	82 16 22 00 	or  %i0, 0x200, %g1	! 50497200 <RAM_END+0x10097200>
4000ee14:	92 10 20 00 	clr  %o1                                       
4000ee18:	94 10 20 00 	clr  %o2                                       
4000ee1c:	90 12 00 01 	or  %o0, %g1, %o0                              
4000ee20:	40 00 06 59 	call  40010784 <rtems_barrier_create>          
4000ee24:	96 07 20 2c 	add  %i4, 0x2c, %o3                            
4000ee28:	80 a2 20 00 	cmp  %o0, 0                                    
4000ee2c:	12 80 00 51 	bne  4000ef70 <fifo_open+0x270>                
4000ee30:	d0 4e a3 90 	ldsb  [ %i2 + 0x390 ], %o0                     
        rtems_build_name ('P', 'I', 'r', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->readBarrier) != RTEMS_SUCCESSFUL)                      
    goto err_rbar;                                                    
  if (rtems_barrier_create(                                           
4000ee34:	03 14 12 5d 	sethi  %hi(0x50497400), %g1                    
4000ee38:	82 10 63 00 	or  %g1, 0x300, %g1	! 50497700 <RAM_END+0x10097700>
4000ee3c:	92 10 20 00 	clr  %o1                                       
4000ee40:	94 10 20 00 	clr  %o2                                       
4000ee44:	90 12 00 01 	or  %o0, %g1, %o0                              
4000ee48:	40 00 06 4f 	call  40010784 <rtems_barrier_create>          
4000ee4c:	96 07 20 30 	add  %i4, 0x30, %o3                            
4000ee50:	80 a2 20 00 	cmp  %o0, 0                                    
4000ee54:	12 80 00 45 	bne  4000ef68 <fifo_open+0x268>                
4000ee58:	d0 4e a3 90 	ldsb  [ %i2 + 0x390 ], %o0                     
        rtems_build_name ('P', 'I', 'w', c),                          
        RTEMS_BARRIER_MANUAL_RELEASE, 0,                              
        &pipe->writeBarrier) != RTEMS_SUCCESSFUL)                     
    goto err_wbar;                                                    
  if (rtems_semaphore_create(                                         
4000ee5c:	b0 16 23 00 	or  %i0, 0x300, %i0                            
4000ee60:	92 10 20 01 	mov  1, %o1                                    
4000ee64:	90 12 00 18 	or  %o0, %i0, %o0                              
4000ee68:	94 10 20 10 	mov  0x10, %o2                                 
4000ee6c:	96 10 20 00 	clr  %o3                                       
4000ee70:	7f ff ea dd 	call  400099e4 <rtems_semaphore_create>        
4000ee74:	98 07 20 28 	add  %i4, 0x28, %o4                            
4000ee78:	80 a2 20 00 	cmp  %o0, 0                                    
4000ee7c:	12 80 00 39 	bne  4000ef60 <fifo_open+0x260>                
4000ee80:	94 07 bf fc 	add  %fp, -4, %o2                              
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (                  
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Barrier_Control *)                                          
4000ee84:	d2 07 20 2c 	ld  [ %i4 + 0x2c ], %o1                        
4000ee88:	21 10 00 96 	sethi  %hi(0x40025800), %l0                    
4000ee8c:	7f ff f2 85 	call  4000b8a0 <_Objects_Get>                  
4000ee90:	90 14 20 a0 	or  %l0, 0xa0, %o0	! 400258a0 <_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;                                
4000ee94:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
4000ee98:	31 04 00 00 	sethi  %hi(0x10000000), %i0                    
4000ee9c:	82 10 40 18 	or  %g1, %i0, %g1                              
  _Thread_Enable_dispatch();                                          
4000eea0:	7f ff f6 37 	call  4000c77c <_Thread_Enable_dispatch>       
4000eea4:	c2 22 20 4c 	st  %g1, [ %o0 + 0x4c ]                        
4000eea8:	d2 07 20 30 	ld  [ %i4 + 0x30 ], %o1                        
4000eeac:	94 07 bf fc 	add  %fp, -4, %o2                              
4000eeb0:	7f ff f2 7c 	call  4000b8a0 <_Objects_Get>                  
4000eeb4:	90 14 20 a0 	or  %l0, 0xa0, %o0                             
  _Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
    |= STATES_INTERRUPTIBLE_BY_SIGNAL;                                
4000eeb8:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
4000eebc:	b0 10 40 18 	or  %g1, %i0, %i0                              
  _Thread_Enable_dispatch();                                          
4000eec0:	7f ff f6 2f 	call  4000c77c <_Thread_Enable_dispatch>       
4000eec4:	f0 22 20 4c 	st  %i0, [ %o0 + 0x4c ]                        
#ifdef RTEMS_POSIX_API                                                
  pipe_interruptible(pipe);                                           
#endif                                                                
                                                                      
  *pipep = pipe;                                                      
  if (c ++ == 'z')                                                    
4000eec8:	c2 4e a3 90 	ldsb  [ %i2 + 0x390 ], %g1                     
4000eecc:	80 a0 60 7a 	cmp  %g1, 0x7a                                 
4000eed0:	02 80 00 21 	be  4000ef54 <fifo_open+0x254>                 
4000eed4:	c4 0e a3 90 	ldub  [ %i2 + 0x390 ], %g2                     
4000eed8:	84 00 a0 01 	inc  %g2                                       
4000eedc:	10 bf ff 9a 	b  4000ed44 <fifo_open+0x44>                   
4000eee0:	c4 2e a3 90 	stb  %g2, [ %i2 + 0x390 ]                      
                                                                      
  if (pipe_semaphore == RTEMS_ID_NONE) {                              
    rtems_libio_lock();                                               
                                                                      
    if (pipe_semaphore == RTEMS_ID_NONE) {                            
      sc = rtems_semaphore_create(                                    
4000eee4:	92 10 20 01 	mov  1, %o1                                    
4000eee8:	94 10 20 54 	mov  0x54, %o2                                 
4000eeec:	96 10 20 00 	clr  %o3                                       
4000eef0:	11 14 12 54 	sethi  %hi(0x50495000), %o0                    
4000eef4:	7f ff ea bc 	call  400099e4 <rtems_semaphore_create>        
4000eef8:	90 12 20 45 	or  %o0, 0x45, %o0	! 50495045 <RAM_END+0x10095045>
4000eefc:	b8 10 00 08 	mov  %o0, %i4                                  
4000ef00:	7f ff eb b0 	call  40009dc0 <rtems_semaphore_release>       
4000ef04:	d0 06 a2 0c 	ld  [ %i2 + 0x20c ], %o0                       
    }                                                                 
                                                                      
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  if (sc == RTEMS_SUCCESSFUL) {                                       
4000ef08:	80 a7 20 00 	cmp  %i4, 0                                    
4000ef0c:	02 bf ff 84 	be  4000ed1c <fifo_open+0x1c>                  
4000ef10:	d0 07 63 20 	ld  [ %i5 + 0x320 ], %o0                       
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
	PIPE_UNLOCK(pipe);                                                   
        err = -ENXIO;                                                 
4000ef14:	81 c7 e0 08 	ret                                            
4000ef18:	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);                            
4000ef1c:	40 00 06 4b 	call  40010848 <rtems_barrier_delete>          <== NOT EXECUTED
4000ef20:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
  rtems_barrier_delete(pipe->writeBarrier);                           
4000ef24:	40 00 06 49 	call  40010848 <rtems_barrier_delete>          <== NOT EXECUTED
4000ef28:	d0 07 20 30 	ld  [ %i4 + 0x30 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete(pipe->Semaphore);                            
4000ef2c:	7f ff eb 1f 	call  40009ba8 <rtems_semaphore_delete>        <== NOT EXECUTED
4000ef30:	d0 07 20 28 	ld  [ %i4 + 0x28 ], %o0                        <== NOT EXECUTED
  free(pipe->Buffer);                                                 
4000ef34:	7f ff d8 eb 	call  400052e0 <free>                          <== NOT EXECUTED
4000ef38:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  free(pipe);                                                         
4000ef3c:	7f ff d8 e9 	call  400052e0 <free>                          <== NOT EXECUTED
4000ef40:	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);                           
4000ef44:	7f ff eb 9f 	call  40009dc0 <rtems_semaphore_release>       
4000ef48:	d0 07 63 20 	ld  [ %i5 + 0x320 ], %o0                       
  return 0;                                                           
                                                                      
out_error:                                                            
  pipe_release(pipep, iop);                                           
  return err;                                                         
}                                                                     
4000ef4c:	81 c7 e0 08 	ret                                            
4000ef50:	81 e8 00 00 	restore                                        
  pipe_interruptible(pipe);                                           
#endif                                                                
                                                                      
  *pipep = pipe;                                                      
  if (c ++ == 'z')                                                    
    c = 'a';                                                          
4000ef54:	82 10 20 61 	mov  0x61, %g1                                 
4000ef58:	10 bf ff 7b 	b  4000ed44 <fifo_open+0x44>                   
4000ef5c:	c2 2e a3 90 	stb  %g1, [ %i2 + 0x390 ]                      
  return 0;                                                           
                                                                      
err_sem:                                                              
  rtems_barrier_delete(pipe->writeBarrier);                           
4000ef60:	40 00 06 3a 	call  40010848 <rtems_barrier_delete>          
4000ef64:	d0 07 20 30 	ld  [ %i4 + 0x30 ], %o0                        
err_wbar:                                                             
  rtems_barrier_delete(pipe->readBarrier);                            
4000ef68:	40 00 06 38 	call  40010848 <rtems_barrier_delete>          
4000ef6c:	d0 07 20 2c 	ld  [ %i4 + 0x2c ], %o0                        
err_rbar:                                                             
  free(pipe->Buffer);                                                 
4000ef70:	7f ff d8 dc 	call  400052e0 <free>                          
4000ef74:	d0 07 00 00 	ld  [ %i4 ], %o0                               
err_buf:                                                              
  free(pipe);                                                         
4000ef78:	7f ff d8 da 	call  400052e0 <free>                          
4000ef7c:	90 10 00 1c 	mov  %i4, %o0                                  
    if (err)                                                          
      goto out;                                                       
  }                                                                   
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    err = -EINTR;                                                     
4000ef80:	10 bf ff f1 	b  4000ef44 <fifo_open+0x244>                  
4000ef84:	b0 10 3f f4 	mov  -12, %i0                                  
                                                                      
  if (*pipep == NULL) {                                               
4000ef88:	80 a0 60 00 	cmp  %g1, 0                                    
4000ef8c:	22 80 00 02 	be,a   4000ef94 <fifo_open+0x294>              
4000ef90:	f8 26 c0 00 	st  %i4, [ %i3 ]                               
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
4000ef94:	7f ff eb 8b 	call  40009dc0 <rtems_semaphore_release>       
4000ef98:	d0 07 63 20 	ld  [ %i5 + 0x320 ], %o0                       
  err = pipe_new(pipep);                                              
  if (err)                                                            
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
4000ef9c:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000efa0:	82 08 60 06 	and  %g1, 6, %g1                               
4000efa4:	80 a0 60 04 	cmp  %g1, 4                                    
4000efa8:	02 80 00 0c 	be  4000efd8 <fifo_open+0x2d8>                 
4000efac:	fa 06 c0 00 	ld  [ %i3 ], %i5                               
4000efb0:	80 a0 60 06 	cmp  %g1, 6                                    
4000efb4:	02 80 00 58 	be  4000f114 <fifo_open+0x414>                 
4000efb8:	80 a0 60 02 	cmp  %g1, 2                                    
4000efbc:	22 80 00 31 	be,a   4000f080 <fifo_open+0x380>              <== ALWAYS TAKEN
4000efc0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
      break;                                                          
  }                                                                   
                                                                      
  PIPE_UNLOCK(pipe);                                                  
4000efc4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
4000efc8:	7f ff eb 7e 	call  40009dc0 <rtems_semaphore_release>       
4000efcc:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
4000efd0:	81 c7 e0 08 	ret                                            
4000efd4:	81 e8 00 00 	restore                                        
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
                                                                      
      if (pipe->Writers ++ == 0)                                      
4000efd8:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
4000efdc:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
                                                                      
      if (pipe->Writers ++ == 0)                                      
4000efe0:	86 00 60 01 	add  %g1, 1, %g3                               
        } while (prevCounter == pipe->writerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
4000efe4:	84 00 a0 01 	inc  %g2                                       
                                                                      
      if (pipe->Writers ++ == 0)                                      
4000efe8:	c6 27 60 14 	st  %g3, [ %i5 + 0x14 ]                        
4000efec:	80 a0 60 00 	cmp  %g1, 0                                    
4000eff0:	02 80 00 68 	be  4000f190 <fifo_open+0x490>                 <== ALWAYS TAKEN
4000eff4:	c4 27 60 24 	st  %g2, [ %i5 + 0x24 ]                        
        PIPE_WAKEUPREADERS(pipe);                                     
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
4000eff8:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        <== NOT EXECUTED
4000effc:	80 a0 60 00 	cmp  %g1, 0                                    
4000f000:	32 bf ff f2 	bne,a   4000efc8 <fifo_open+0x2c8>             
4000f004:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
4000f008:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000f00c:	80 88 60 01 	btst  1, %g1                                   
4000f010:	32 80 00 65 	bne,a   4000f1a4 <fifo_open+0x4a4>             
4000f014:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        err = -ENXIO;                                                 
        goto out_error;                                               
      }                                                               
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
4000f018:	10 80 00 0c 	b  4000f048 <fifo_open+0x348>                  
4000f01c:	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))                                      
4000f020:	92 10 20 00 	clr  %o1                                       
4000f024:	7f ff eb 18 	call  40009c84 <rtems_semaphore_obtain>        
4000f028:	94 10 20 00 	clr  %o2                                       
4000f02c:	80 a2 20 00 	cmp  %o0, 0                                    
4000f030:	12 80 00 0f 	bne  4000f06c <fifo_open+0x36c>                <== NEVER TAKEN
4000f034:	b0 10 3f fc 	mov  -4, %i0                                   
            goto out_error;                                           
        } while (prevCounter == pipe->readerCounter);                 
4000f038:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
4000f03c:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000f040:	32 bf ff e2 	bne,a   4000efc8 <fifo_open+0x2c8>             <== ALWAYS TAKEN
4000f044:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
      if (pipe->Readers == 0) {                                       
        prevCounter = pipe->readerCounter;                            
        err = -EINTR;                                                 
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
4000f048:	7f ff eb 5e 	call  40009dc0 <rtems_semaphore_release>       
4000f04c:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
          if (! PIPE_WRITEWAIT(pipe))                                 
4000f050:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000f054:	40 00 06 3e 	call  4001094c <rtems_barrier_wait>            
4000f058:	92 10 20 00 	clr  %o1                                       
4000f05c:	80 a2 20 00 	cmp  %o0, 0                                    
4000f060:	22 bf ff f0 	be,a   4000f020 <fifo_open+0x320>              <== ALWAYS TAKEN
4000f064:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
        err = -EINTR;                                                 
4000f068:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
                                                                      
  PIPE_UNLOCK(pipe);                                                  
  return 0;                                                           
                                                                      
out_error:                                                            
  pipe_release(pipep, iop);                                           
4000f06c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000f070:	7f ff fe e5 	call  4000ec04 <pipe_release>                  
4000f074:	92 10 00 19 	mov  %i1, %o1                                  
  return err;                                                         
4000f078:	81 c7 e0 08 	ret                                            
4000f07c:	81 e8 00 00 	restore                                        
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
4000f080:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
      if (pipe->Readers ++ == 0)                                      
4000f084:	86 00 60 01 	add  %g1, 1, %g3                               
    return err;                                                       
  pipe = *pipep;                                                      
                                                                      
  switch (LIBIO_ACCMODE(iop)) {                                       
    case LIBIO_FLAGS_READ:                                            
      pipe->readerCounter ++;                                         
4000f088:	84 00 a0 01 	inc  %g2                                       
      if (pipe->Readers ++ == 0)                                      
4000f08c:	c6 27 60 10 	st  %g3, [ %i5 + 0x10 ]                        
4000f090:	80 a0 60 00 	cmp  %g1, 0                                    
4000f094:	02 80 00 35 	be  4000f168 <fifo_open+0x468>                 <== ALWAYS TAKEN
4000f098:	c4 27 60 20 	st  %g2, [ %i5 + 0x20 ]                        
        PIPE_WAKEUPWRITERS(pipe);                                     
                                                                      
      if (pipe->Writers == 0) {                                       
4000f09c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        <== NOT EXECUTED
4000f0a0:	80 a0 60 00 	cmp  %g1, 0                                    
4000f0a4:	32 bf ff c9 	bne,a   4000efc8 <fifo_open+0x2c8>             
4000f0a8:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
4000f0ac:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4000f0b0:	80 88 60 01 	btst  1, %g1                                   
4000f0b4:	32 bf ff c5 	bne,a   4000efc8 <fifo_open+0x2c8>             
4000f0b8:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
4000f0bc:	10 80 00 0c 	b  4000f0ec <fifo_open+0x3ec>                  
4000f0c0:	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))                                      
4000f0c4:	92 10 20 00 	clr  %o1                                       
4000f0c8:	7f ff ea ef 	call  40009c84 <rtems_semaphore_obtain>        
4000f0cc:	94 10 20 00 	clr  %o2                                       
4000f0d0:	80 a2 20 00 	cmp  %o0, 0                                    
4000f0d4:	12 bf ff e6 	bne  4000f06c <fifo_open+0x36c>                <== NEVER TAKEN
4000f0d8:	b0 10 3f fc 	mov  -4, %i0                                   
            goto out_error;                                           
        } while (prevCounter == pipe->writerCounter);                 
4000f0dc:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
4000f0e0:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000f0e4:	32 bf ff b9 	bne,a   4000efc8 <fifo_open+0x2c8>             <== ALWAYS TAKEN
4000f0e8:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
        prevCounter = pipe->writerCounter;                            
        err = -EINTR;                                                 
        /* Wait until a writer opens the pipe */                      
        do {                                                          
          PIPE_UNLOCK(pipe);                                          
4000f0ec:	7f ff eb 35 	call  40009dc0 <rtems_semaphore_release>       
4000f0f0:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
          if (! PIPE_READWAIT(pipe))                                  
4000f0f4:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000f0f8:	40 00 06 15 	call  4001094c <rtems_barrier_wait>            
4000f0fc:	92 10 20 00 	clr  %o1                                       
4000f100:	80 a2 20 00 	cmp  %o0, 0                                    
4000f104:	22 bf ff f0 	be,a   4000f0c4 <fifo_open+0x3c4>              <== ALWAYS TAKEN
4000f108:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
        /* Not an error */                                            
        if (LIBIO_NODELAY(iop))                                       
          break;                                                      
                                                                      
        prevCounter = pipe->writerCounter;                            
        err = -EINTR;                                                 
4000f10c:	10 bf ff d8 	b  4000f06c <fifo_open+0x36c>                  <== NOT EXECUTED
4000f110:	b0 10 3f fc 	mov  -4, %i0                                   <== NOT EXECUTED
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
4000f114:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
4000f118:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
      if (pipe->Readers ++ == 0)                                      
4000f11c:	86 00 60 01 	add  %g1, 1, %g3                               
        } while (prevCounter == pipe->readerCounter);                 
      }                                                               
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
4000f120:	84 00 a0 01 	inc  %g2                                       
      if (pipe->Readers ++ == 0)                                      
4000f124:	c6 27 60 10 	st  %g3, [ %i5 + 0x10 ]                        
4000f128:	80 a0 60 00 	cmp  %g1, 0                                    
4000f12c:	02 80 00 14 	be  4000f17c <fifo_open+0x47c>                 <== ALWAYS TAKEN
4000f130:	c4 27 60 20 	st  %g2, [ %i5 + 0x20 ]                        
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
      if (pipe->Writers ++ == 0)                                      
4000f134:	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 ++;                                         
4000f138:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
      if (pipe->Writers ++ == 0)                                      
4000f13c:	86 00 60 01 	add  %g1, 1, %g3                               
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
      pipe->writerCounter ++;                                         
4000f140:	84 00 a0 01 	inc  %g2                                       
      if (pipe->Writers ++ == 0)                                      
4000f144:	c6 27 60 14 	st  %g3, [ %i5 + 0x14 ]                        
4000f148:	80 a0 60 00 	cmp  %g1, 0                                    
4000f14c:	12 bf ff 9e 	bne  4000efc4 <fifo_open+0x2c4>                <== NEVER TAKEN
4000f150:	c4 27 60 24 	st  %g2, [ %i5 + 0x24 ]                        
        PIPE_WAKEUPREADERS(pipe);                                     
4000f154:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000f158:	40 00 05 e5 	call  400108ec <rtems_barrier_release>         
4000f15c:	92 07 bf f8 	add  %fp, -8, %o1                              
      break;                                                          
  }                                                                   
                                                                      
  PIPE_UNLOCK(pipe);                                                  
4000f160:	10 bf ff 9a 	b  4000efc8 <fifo_open+0x2c8>                  
4000f164:	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);                                     
4000f168:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000f16c:	40 00 05 e0 	call  400108ec <rtems_barrier_release>         
4000f170:	92 07 bf f8 	add  %fp, -8, %o1                              
                                                                      
      if (pipe->Writers == 0) {                                       
4000f174:	10 bf ff cb 	b  4000f0a0 <fifo_open+0x3a0>                  
4000f178:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
      break;                                                          
                                                                      
    case LIBIO_FLAGS_READ_WRITE:                                      
      pipe->readerCounter ++;                                         
      if (pipe->Readers ++ == 0)                                      
        PIPE_WAKEUPWRITERS(pipe);                                     
4000f17c:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000f180:	40 00 05 db 	call  400108ec <rtems_barrier_release>         
4000f184:	92 07 bf f8 	add  %fp, -8, %o1                              
      pipe->writerCounter ++;                                         
      if (pipe->Writers ++ == 0)                                      
4000f188:	10 bf ff ec 	b  4000f138 <fifo_open+0x438>                  
4000f18c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
    case LIBIO_FLAGS_WRITE:                                           
      pipe->writerCounter ++;                                         
                                                                      
      if (pipe->Writers ++ == 0)                                      
        PIPE_WAKEUPREADERS(pipe);                                     
4000f190:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000f194:	40 00 05 d6 	call  400108ec <rtems_barrier_release>         
4000f198:	92 07 bf f8 	add  %fp, -8, %o1                              
                                                                      
      if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {                 
4000f19c:	10 bf ff 98 	b  4000effc <fifo_open+0x2fc>                  
4000f1a0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
	PIPE_UNLOCK(pipe);                                                   
4000f1a4:	7f ff eb 07 	call  40009dc0 <rtems_semaphore_release>       
4000f1a8:	b0 10 3f fa 	mov  -6, %i0                                   
        err = -ENXIO;                                                 
        goto out_error;                                               
4000f1ac:	10 bf ff b1 	b  4000f070 <fifo_open+0x370>                  
4000f1b0:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      

4000aa74 <fpathconf>: */ long fpathconf( int fd, int name ) {
4000aa74:	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);                                           
4000aa78:	03 10 00 4d 	sethi  %hi(0x40013400), %g1                    
4000aa7c:	c2 00 61 e8 	ld  [ %g1 + 0x1e8 ], %g1	! 400135e8 <rtems_libio_number_iops>
4000aa80:	80 a6 00 01 	cmp  %i0, %g1                                  
4000aa84:	1a 80 00 3e 	bcc  4000ab7c <fpathconf+0x108>                
4000aa88:	03 10 00 4f 	sethi  %hi(0x40013c00), %g1                    
  iop = rtems_libio_iop(fd);                                          
4000aa8c:	c2 00 63 b4 	ld  [ %g1 + 0x3b4 ], %g1	! 40013fb4 <rtems_libio_iops>
4000aa90:	85 2e 20 03 	sll  %i0, 3, %g2                               
4000aa94:	b1 2e 20 06 	sll  %i0, 6, %i0                               
4000aa98:	b0 26 00 02 	sub  %i0, %g2, %i0                             
4000aa9c:	b0 00 40 18 	add  %g1, %i0, %i0                             
  rtems_libio_check_is_open(iop);                                     
4000aaa0:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4000aaa4:	80 88 61 00 	btst  0x100, %g1                               
4000aaa8:	02 80 00 35 	be  4000ab7c <fpathconf+0x108>                 <== NEVER TAKEN
4000aaac:	80 a6 60 0b 	cmp  %i1, 0xb                                  
                                                                      
  /*                                                                  
   *  Now process the information request.                            
   */                                                                 
                                                                      
  the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;   
4000aab0:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
  switch ( name ) {                                                   
4000aab4:	08 80 00 08 	bleu  4000aad4 <fpathconf+0x60>                
4000aab8:	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 );                 
4000aabc:	40 00 09 72 	call  4000d084 <__errno>                       
4000aac0:	b0 10 3f ff 	mov  -1, %i0                                   
4000aac4:	82 10 20 16 	mov  0x16, %g1                                 
4000aac8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      break;                                                          
  }                                                                   
                                                                      
  return return_value;                                                
}                                                                     
4000aacc:	81 c7 e0 08 	ret                                            
4000aad0:	81 e8 00 00 	restore                                        
   *  Now process the information request.                            
   */                                                                 
                                                                      
  the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;   
                                                                      
  switch ( name ) {                                                   
4000aad4:	b3 2e 60 02 	sll  %i1, 2, %i1                               
4000aad8:	05 10 00 2a 	sethi  %hi(0x4000a800), %g2                    
4000aadc:	84 10 a2 44 	or  %g2, 0x244, %g2	! 4000aa44 <_close_r+0x10> 
4000aae0:	c4 00 80 19 	ld  [ %g2 + %i1 ], %g2                         
4000aae4:	81 c0 80 00 	jmp  %g2                                       
4000aae8:	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;                       
4000aaec:	f0 00 60 24 	ld  [ %g1 + 0x24 ], %i0                        
      break;                                                          
4000aaf0:	81 c7 e0 08 	ret                                            
4000aaf4:	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;                      
4000aaf8:	f0 00 60 18 	ld  [ %g1 + 0x18 ], %i0                        
      break;                                                          
4000aafc:	81 c7 e0 08 	ret                                            
4000ab00:	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;                      
4000ab04:	f0 00 60 2c 	ld  [ %g1 + 0x2c ], %i0                        
      break;                                                          
4000ab08:	81 c7 e0 08 	ret                                            
4000ab0c:	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;                      
4000ab10:	f0 00 60 20 	ld  [ %g1 + 0x20 ], %i0                        
      break;                                                          
4000ab14:	81 c7 e0 08 	ret                                            
4000ab18:	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;            
4000ab1c:	f0 00 60 1c 	ld  [ %g1 + 0x1c ], %i0                        
      break;                                                          
4000ab20:	81 c7 e0 08 	ret                                            
4000ab24:	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;                            
4000ab28:	f0 00 60 14 	ld  [ %g1 + 0x14 ], %i0                        
      break;                                                          
4000ab2c:	81 c7 e0 08 	ret                                            
4000ab30:	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;                            
4000ab34:	f0 00 60 10 	ld  [ %g1 + 0x10 ], %i0                        
      break;                                                          
4000ab38:	81 c7 e0 08 	ret                                            
4000ab3c:	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;                            
4000ab40:	f0 00 60 0c 	ld  [ %g1 + 0xc ], %i0                         
      break;                                                          
4000ab44:	81 c7 e0 08 	ret                                            
4000ab48:	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;                           
4000ab4c:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
      break;                                                          
4000ab50:	81 c7 e0 08 	ret                                            
4000ab54:	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;                           
4000ab58:	f0 00 60 04 	ld  [ %g1 + 4 ], %i0                           
      break;                                                          
4000ab5c:	81 c7 e0 08 	ret                                            
4000ab60:	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;                            
4000ab64:	f0 00 40 00 	ld  [ %g1 ], %i0                               
      break;                                                          
4000ab68:	81 c7 e0 08 	ret                                            
4000ab6c:	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;                       
4000ab70:	f0 00 60 28 	ld  [ %g1 + 0x28 ], %i0                        
      break;                                                          
4000ab74:	81 c7 e0 08 	ret                                            
4000ab78:	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);                                     
4000ab7c:	40 00 09 42 	call  4000d084 <__errno>                       
4000ab80:	b0 10 3f ff 	mov  -1, %i0                                   
4000ab84:	82 10 20 09 	mov  9, %g1                                    
4000ab88:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000ab8c:	81 c7 e0 08 	ret                                            
4000ab90:	81 e8 00 00 	restore                                        
                                                                      

40004208 <free>: #include <stdlib.h> void free( void *ptr ) {
40004208:	9d e3 bf a0 	save  %sp, -96, %sp                            
  MSBUMP(free_calls, 1);                                              
4000420c:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
40004210:	82 10 61 30 	or  %g1, 0x130, %g1	! 40020130 <rtems_malloc_statistics>
40004214:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
#include <stdlib.h>                                                   
                                                                      
void free(                                                            
  void *ptr                                                           
)                                                                     
{                                                                     
40004218:	b2 10 00 18 	mov  %i0, %i1                                  
  MSBUMP(free_calls, 1);                                              
4000421c:	84 00 a0 01 	inc  %g2                                       
                                                                      
  if ( !ptr )                                                         
40004220:	80 a6 20 00 	cmp  %i0, 0                                    
40004224:	02 80 00 15 	be  40004278 <free+0x70>                       
40004228:	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()) &&                    
4000422c:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
40004230:	c2 00 63 b8 	ld  [ %g1 + 0x3b8 ], %g1	! 400207b8 <_System_state_Current>
40004234:	80 a0 60 03 	cmp  %g1, 3                                    
40004238:	02 80 00 17 	be  40004294 <free+0x8c>                       <== ALWAYS TAKEN
4000423c:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
  }                                                                   
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
40004240:	c2 00 60 90 	ld  [ %g1 + 0x90 ], %g1	! 4001fc90 <rtems_malloc_statistics_helpers>
40004244:	80 a0 60 00 	cmp  %g1, 0                                    
40004248:	02 80 00 06 	be  40004260 <free+0x58>                       
4000424c:	3b 10 00 7d 	sethi  %hi(0x4001f400), %i5                    
    (*rtems_malloc_statistics_helpers->at_free)(ptr);                 
40004250:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40004254:	9f c0 40 00 	call  %g1                                      
40004258:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {            
4000425c:	3b 10 00 7d 	sethi  %hi(0x4001f400), %i5                    
40004260:	d0 07 61 60 	ld  [ %i5 + 0x160 ], %o0	! 4001f560 <RTEMS_Malloc_Heap>
40004264:	40 00 18 8e 	call  4000a49c <_Protected_heap_Free>          
40004268:	92 10 00 19 	mov  %i1, %o1                                  
4000426c:	80 8a 20 ff 	btst  0xff, %o0                                
40004270:	02 80 00 04 	be  40004280 <free+0x78>                       
40004274:	c2 07 61 60 	ld  [ %i5 + 0x160 ], %g1                       
40004278:	81 c7 e0 08 	ret                                            
4000427c:	81 e8 00 00 	restore                                        
    printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
40004280:	31 10 00 77 	sethi  %hi(0x4001dc00), %i0                    
40004284:	f4 00 60 18 	ld  [ %g1 + 0x18 ], %i2                        
40004288:	f6 00 60 1c 	ld  [ %g1 + 0x1c ], %i3                        
4000428c:	40 00 03 81 	call  40005090 <printk>                        
40004290:	91 ee 23 18 	restore  %i0, 0x318, %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() ) {                               
40004294:	40 00 00 67 	call  40004430 <malloc_is_system_state_OK>     
40004298:	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()) &&                    
4000429c:	80 8a 20 ff 	btst  0xff, %o0                                
400042a0:	12 bf ff e8 	bne  40004240 <free+0x38>                      
400042a4:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
       !malloc_is_system_state_OK() ) {                               
      malloc_deferred_free(ptr);                                      
400042a8:	40 00 00 7c 	call  40004498 <malloc_deferred_free>          
400042ac:	81 e8 00 00 	restore                                        
                                                                      

4001c74c <fstat>: int fstat( int fd, struct stat *sbuf ) {
4001c74c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t *iop;                                                 
                                                                      
  /*                                                                  
   *  Check to see if we were passed a valid pointer.                 
   */                                                                 
  if ( !sbuf )                                                        
4001c750:	80 a6 60 00 	cmp  %i1, 0                                    
4001c754:	02 80 00 1f 	be  4001c7d0 <fstat+0x84>                      <== NEVER TAKEN
4001c758:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
    rtems_set_errno_and_return_minus_one( EFAULT );                   
                                                                      
  /*                                                                  
   *  Now process the stat() request.                                 
   */                                                                 
  iop = rtems_libio_iop( fd );                                        
4001c75c:	c2 00 61 a4 	ld  [ %g1 + 0x1a4 ], %g1	! 4001f5a4 <rtems_libio_number_iops>
4001c760:	80 a6 00 01 	cmp  %i0, %g1                                  
4001c764:	1a 80 00 15 	bcc  4001c7b8 <fstat+0x6c>                     
4001c768:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4001c76c:	c2 00 61 24 	ld  [ %g1 + 0x124 ], %g1	! 40020124 <rtems_libio_iops>
4001c770:	85 2e 20 03 	sll  %i0, 3, %g2                               
4001c774:	b1 2e 20 06 	sll  %i0, 6, %i0                               
4001c778:	b0 26 00 02 	sub  %i0, %g2, %i0                             
4001c77c:	b0 00 40 18 	add  %g1, %i0, %i0                             
  rtems_libio_check_fd( fd );                                         
  rtems_libio_check_is_open(iop);                                     
4001c780:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4001c784:	80 88 61 00 	btst  0x100, %g1                               
4001c788:	02 80 00 0c 	be  4001c7b8 <fstat+0x6c>                      
4001c78c:	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) );                             
4001c790:	92 10 20 00 	clr  %o1                                       
4001c794:	7f ff d2 f9 	call  40011378 <memset>                        
4001c798:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );  
4001c79c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4001c7a0:	90 06 20 14 	add  %i0, 0x14, %o0                            
4001c7a4:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
4001c7a8:	9f c0 40 00 	call  %g1                                      
4001c7ac:	92 10 00 19 	mov  %i1, %o1                                  
}                                                                     
4001c7b0:	81 c7 e0 08 	ret                                            
4001c7b4:	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);                                     
4001c7b8:	7f ff d0 62 	call  40010940 <__errno>                       
4001c7bc:	b0 10 3f ff 	mov  -1, %i0                                   
4001c7c0:	82 10 20 09 	mov  9, %g1                                    
4001c7c4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001c7c8:	81 c7 e0 08 	ret                                            
4001c7cc:	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 );                   
4001c7d0:	7f ff d0 5c 	call  40010940 <__errno>                       <== NOT EXECUTED
4001c7d4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001c7d8:	82 10 20 0e 	mov  0xe, %g1                                  <== NOT EXECUTED
4001c7dc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001c7e0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c7e4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400040f8 <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) {
400040f8:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
400040fc:	c2 00 60 70 	ld  [ %g1 + 0x70 ], %g1	! 4001c470 <disktab_size>
40004100:	80 a0 40 08 	cmp  %g1, %o0                                  
40004104:	08 80 00 20 	bleu  40004184 <get_disk_entry+0x8c>           <== NEVER TAKEN
40004108:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
4000410c:	c2 00 60 74 	ld  [ %g1 + 0x74 ], %g1	! 4001c474 <disktab>   
40004110:	80 a0 60 00 	cmp  %g1, 0                                    
40004114:	02 80 00 1c 	be  40004184 <get_disk_entry+0x8c>             <== NEVER TAKEN
40004118:	01 00 00 00 	nop                                            
    rtems_disk_device_table *dtab = disktab + major;                  
4000411c:	91 2a 20 03 	sll  %o0, 3, %o0                               
40004120:	84 00 40 08 	add  %g1, %o0, %g2                             
                                                                      
    if (minor < dtab->size && dtab->minor != NULL) {                  
40004124:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
40004128:	80 a0 80 09 	cmp  %g2, %o1                                  
4000412c:	08 80 00 16 	bleu  40004184 <get_disk_entry+0x8c>           <== NEVER TAKEN
40004130:	01 00 00 00 	nop                                            
40004134:	c2 00 40 08 	ld  [ %g1 + %o0 ], %g1                         
40004138:	80 a0 60 00 	cmp  %g1, 0                                    
4000413c:	02 80 00 12 	be  40004184 <get_disk_entry+0x8c>             <== NEVER TAKEN
40004140:	93 2a 60 02 	sll  %o1, 2, %o1                               
      rtems_disk_device *dd = dtab->minor [minor];                    
                                                                      
      if (dd != NULL && !lookup_only) {                               
40004144:	80 a2 a0 01 	cmp  %o2, 1                                    
40004148:	12 80 00 04 	bne  40004158 <get_disk_entry+0x60>            
4000414c:	d0 00 40 09 	ld  [ %g1 + %o1 ], %o0                         
      return dd;                                                      
    }                                                                 
  }                                                                   
                                                                      
  return NULL;                                                        
}                                                                     
40004150:	81 c3 e0 08 	retl                                           
40004154:	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) {                               
40004158:	80 a2 20 00 	cmp  %o0, 0                                    
4000415c:	02 bf ff fd 	be  40004150 <get_disk_entry+0x58>             <== NEVER TAKEN
40004160:	01 00 00 00 	nop                                            
        if (!dd->deleted) {                                           
40004164:	c2 0a 20 40 	ldub  [ %o0 + 0x40 ], %g1                      
40004168:	80 a0 60 00 	cmp  %g1, 0                                    
4000416c:	12 80 00 06 	bne  40004184 <get_disk_entry+0x8c>            
40004170:	01 00 00 00 	nop                                            
          ++dd->uses;                                                 
40004174:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
40004178:	82 00 60 01 	inc  %g1                                       
4000417c:	81 c3 e0 08 	retl                                           
40004180:	c2 22 20 14 	st  %g1, [ %o0 + 0x14 ]                        
      return dd;                                                      
    }                                                                 
  }                                                                   
                                                                      
  return NULL;                                                        
}                                                                     
40004184:	81 c3 e0 08 	retl                                           
40004188:	90 10 20 00 	clr  %o0                                       
                                                                      

400056c4 <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,
400056c4:	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);
400056c8:	40 00 05 41 	call  40006bcc <malloc>                        
400056cc:	90 10 22 04 	mov  0x204, %o0                                
    if (s == NULL)                                                    
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
400056d0:	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)                                                    
400056d4:	80 a2 20 00 	cmp  %o0, 0                                    
400056d8:	02 80 00 0c 	be  40005708 <get_sector.part.0+0x44>          <== NEVER TAKEN
400056dc:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);                     
400056e0:	90 10 00 18 	mov  %i0, %o0                                  
400056e4:	92 07 60 04 	add  %i5, 4, %o1                               
400056e8:	40 00 07 eb 	call  40007694 <read>                          
400056ec:	94 10 22 00 	mov  0x200, %o2                                
    if (n != RTEMS_IDE_SECTOR_SIZE)                                   
400056f0:	80 a2 22 00 	cmp  %o0, 0x200                                
400056f4:	02 80 00 07 	be  40005710 <get_sector.part.0+0x4c>          <== ALWAYS TAKEN
400056f8:	82 10 20 00 	clr  %g1                                       
    {                                                                 
        free(s);                                                      
400056fc:	40 00 03 97 	call  40006558 <free>                          <== NOT EXECUTED
40005700:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        return RTEMS_IO_ERROR;                                        
40005704:	82 10 20 1b 	mov  0x1b, %g1                                 <== NOT EXECUTED
    s->sector_num = sector_num;                                       
                                                                      
    *sector = s;                                                      
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40005708:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000570c:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
    {                                                                 
        free(s);                                                      
        return RTEMS_IO_ERROR;                                        
    }                                                                 
                                                                      
    s->sector_num = sector_num;                                       
40005710:	f2 27 40 00 	st  %i1, [ %i5 ]                               
                                                                      
    *sector = s;                                                      
40005714:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40005718:	81 c7 e0 08 	ret                                            
4000571c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

400343f0 <getdents>: int getdents( int dd_fd, char *dd_buf, int dd_len ) {
400343f0:	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 );                                     
400343f4:	03 10 00 e8 	sethi  %hi(0x4003a000), %g1                    
400343f8:	c2 00 63 ac 	ld  [ %g1 + 0x3ac ], %g1	! 4003a3ac <rtems_libio_number_iops>
400343fc:	80 a6 00 01 	cmp  %i0, %g1                                  
40034400:	1a 80 00 08 	bcc  40034420 <getdents+0x30>                  <== NEVER TAKEN
40034404:	ba 10 20 00 	clr  %i5                                       
40034408:	03 10 01 2c 	sethi  %hi(0x4004b000), %g1                    
4003440c:	fa 00 60 94 	ld  [ %g1 + 0x94 ], %i5	! 4004b094 <rtems_libio_iops>
40034410:	83 2e 20 03 	sll  %i0, 3, %g1                               
40034414:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40034418:	b0 26 00 01 	sub  %i0, %g1, %i0                             
4003441c:	ba 07 40 18 	add  %i5, %i0, %i5                             
                                                                      
  /*                                                                  
   *  Make sure we are working on a directory                         
   */                                                                 
  type = rtems_filesystem_node_type( &iop->pathinfo );                
40034420:	7f ff 5b 59 	call  4000b184 <rtems_filesystem_node_type>    
40034424:	90 07 60 14 	add  %i5, 0x14, %o0                            
  if ( type != RTEMS_FILESYSTEM_DIRECTORY )                           
40034428:	80 a2 20 00 	cmp  %o0, 0                                    
4003442c:	12 80 00 09 	bne  40034450 <getdents+0x60>                  
40034430:	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  );   
40034434:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
40034438:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
4003443c:	92 10 00 19 	mov  %i1, %o1                                  
40034440:	9f c0 40 00 	call  %g1                                      
40034444:	94 10 00 1a 	mov  %i2, %o2                                  
}                                                                     
40034448:	81 c7 e0 08 	ret                                            
4003444c:	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 );                  
40034450:	7f ff bd ba 	call  40023b38 <__errno>                       
40034454:	b0 10 3f ff 	mov  -1, %i0                                   
40034458:	82 10 20 14 	mov  0x14, %g1                                 
4003445c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40034460:	81 c7 e0 08 	ret                                            
40034464:	81 e8 00 00 	restore                                        
                                                                      

4000fdac <imfs_dir_read>: ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) {
4000fdac:	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;
4000fdb0:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->lock_h)( mt_entry );                               
4000fdb4:	c4 02 20 0c 	ld  [ %o0 + 0xc ], %g2                         
4000fdb8:	c2 00 80 00 	ld  [ %g2 ], %g1                               
4000fdbc:	9f c0 40 00 	call  %g1                                      
4000fdc0:	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;             
4000fdc4:	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;                                         
4000fdc8:	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 );   
4000fdcc:	90 10 00 1a 	mov  %i2, %o0                                  
4000fdd0:	40 00 27 29 	call  40019a74 <.udiv>                         
4000fdd4:	92 10 21 18 	mov  0x118, %o1                                
4000fdd8:	83 2a 20 03 	sll  %o0, 3, %g1                               
4000fddc:	91 2a 20 05 	sll  %o0, 5, %o0                               
4000fde0:	82 00 40 08 	add  %g1, %o0, %g1                             
4000fde4:	a3 28 60 03 	sll  %g1, 3, %l1                               
4000fde8:	a2 24 40 01 	sub  %l1, %g1, %l1                             
4000fdec:	a2 04 40 10 	add  %l1, %l0, %l1                             
                                                                      
   /* The directory was not empty so try to move to the desired entry in chain*/
   for (                                                              
4000fdf0:	80 a4 60 00 	cmp  %l1, 0                                    
4000fdf4:	04 80 00 34 	ble  4000fec4 <imfs_dir_read+0x118>            <== NEVER TAKEN
4000fdf8:	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 ));            
4000fdfc:	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 );               
4000fe00:	80 a6 80 12 	cmp  %i2, %l2                                  
4000fe04:	02 80 00 29 	be  4000fea8 <imfs_dir_read+0xfc>              
4000fe08:	a6 10 20 00 	clr  %l3                                       
4000fe0c:	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 );               
4000fe10:	10 80 00 08 	b  4000fe30 <imfs_dir_read+0x84>               
4000fe14:	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 (                                                              
4000fe18:	80 a4 40 1b 	cmp  %l1, %i3                                  
4000fe1c:	04 80 00 23 	ble  4000fea8 <imfs_dir_read+0xfc>             <== NEVER TAKEN
4000fe20:	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 );               
4000fe24:	80 a6 80 12 	cmp  %i2, %l2                                  
4000fe28:	22 80 00 21 	be,a   4000feac <imfs_dir_read+0x100>          
4000fe2c:	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 ) {                            
4000fe30:	80 a4 00 1b 	cmp  %l0, %i3                                  
4000fe34:	34 bf ff f9 	bg,a   4000fe18 <imfs_dir_read+0x6c>           
4000fe38:	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;                        
4000fe3c:	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;                            
4000fe40:	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 );             
4000fe44:	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;                            
4000fe48:	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;                        
4000fe4c:	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;                            
4000fe50:	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 );             
4000fe54:	90 10 00 1d 	mov  %i5, %o0                                  
4000fe58:	40 00 08 1f 	call  40011ed4 <strlen>                        
4000fe5c:	e8 37 be f8 	sth  %l4, [ %fp + -264 ]                       
         strcpy( tmp_dirent.d_name, the_jnode->name );                
4000fe60:	92 10 00 1d 	mov  %i5, %o1                                  
4000fe64:	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 );             
4000fe68:	d0 37 be fa 	sth  %o0, [ %fp + -262 ]                       
         strcpy( tmp_dirent.d_name, the_jnode->name );                
4000fe6c:	40 00 05 06 	call  40011284 <memcpy>                        
4000fe70:	90 07 be fc 	add  %fp, -260, %o0                            
         memcpy(                                                      
4000fe74:	90 06 40 13 	add  %i1, %l3, %o0                             
4000fe78:	92 07 be e8 	add  %fp, -280, %o1                            
4000fe7c:	40 00 05 02 	call  40011284 <memcpy>                        
4000fe80:	94 10 21 18 	mov  0x118, %o2                                
            buffer + bytes_transferred,                               
            (void *)&tmp_dirent,                                      
            sizeof( struct dirent )                                   
         );                                                           
         iop->offset += sizeof( struct dirent );                      
4000fe84:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
#include "imfs.h"                                                     
                                                                      
#include <string.h>                                                   
#include <dirent.h>                                                   
                                                                      
ssize_t imfs_dir_read(                                                
4000fe88:	b6 06 e1 18 	add  %i3, 0x118, %i3                           
         memcpy(                                                      
            buffer + bytes_transferred,                               
            (void *)&tmp_dirent,                                      
            sizeof( struct dirent )                                   
         );                                                           
         iop->offset += sizeof( struct dirent );                      
4000fe8c:	ba 80 e1 18 	addcc  %g3, 0x118, %i5                         
4000fe90:	b8 40 a0 00 	addx  %g2, 0, %i4                              
4000fe94:	f8 3e 20 08 	std  %i4, [ %i0 + 8 ]                          
         bytes_transferred += sizeof( struct dirent );                
4000fe98:	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 (                                                              
4000fe9c:	80 a4 40 1b 	cmp  %l1, %i3                                  
4000fea0:	14 bf ff e1 	bg  4000fe24 <imfs_dir_read+0x78>              <== NEVER TAKEN
4000fea4:	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;
4000fea8:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
                                                                      
  (*mt_entry->ops->unlock_h)( mt_entry );                             
4000feac:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
4000feb0:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000feb4:	9f c0 40 00 	call  %g1                                      
4000feb8:	b0 10 00 13 	mov  %l3, %i0                                  
   }                                                                  
                                                                      
   rtems_filesystem_instance_unlock( &iop->pathinfo );                
                                                                      
   return bytes_transferred;                                          
}                                                                     
4000febc:	81 c7 e0 08 	ret                                            
4000fec0:	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;                                             
4000fec4:	10 bf ff f9 	b  4000fea8 <imfs_dir_read+0xfc>               <== NOT EXECUTED
4000fec8:	a6 10 20 00 	clr  %l3                                       <== NOT EXECUTED
                                                                      

400283a0 <init_etc_passwd_group>: /** * Initialize useable but dummy databases */ void init_etc_passwd_group(void) {
400283a0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  FILE *fp;                                                           
  static char etc_passwd_initted = 0;                                 
                                                                      
  if (etc_passwd_initted)                                             
400283a4:	03 10 01 a3 	sethi  %hi(0x40068c00), %g1                    
400283a8:	c4 48 63 a0 	ldsb  [ %g1 + 0x3a0 ], %g2	! 40068fa0 <etc_passwd_initted.7068>
400283ac:	80 a0 a0 00 	cmp  %g2, 0                                    
400283b0:	02 80 00 04 	be  400283c0 <init_etc_passwd_group+0x20>      
400283b4:	84 10 20 01 	mov  1, %g2                                    
400283b8:	81 c7 e0 08 	ret                                            
400283bc:	81 e8 00 00 	restore                                        
    return;                                                           
  etc_passwd_initted = 1;                                             
  mkdir("/etc", 0777);                                                
400283c0:	92 10 21 ff 	mov  0x1ff, %o1                                
  FILE *fp;                                                           
  static char etc_passwd_initted = 0;                                 
                                                                      
  if (etc_passwd_initted)                                             
    return;                                                           
  etc_passwd_initted = 1;                                             
400283c4:	c4 28 63 a0 	stb  %g2, [ %g1 + 0x3a0 ]                      
  mkdir("/etc", 0777);                                                
400283c8:	11 10 01 81 	sethi  %hi(0x40060400), %o0                    
400283cc:	7f ff 6f 80 	call  400041cc <mkdir>                         
400283d0:	90 12 22 08 	or  %o0, 0x208, %o0	! 40060608 <rtems_status_assoc+0x168>
                                                                      
  /*                                                                  
   *  Initialize /etc/passwd                                          
   */                                                                 
  if ((fp = fopen("/etc/passwd", "r")) != NULL) {                     
400283d4:	39 10 01 81 	sethi  %hi(0x40060400), %i4                    
400283d8:	3b 10 01 93 	sethi  %hi(0x40064c00), %i5                    
400283dc:	90 17 22 10 	or  %i4, 0x210, %o0                            
400283e0:	40 00 53 92 	call  4003d228 <fopen>                         
400283e4:	92 17 60 a0 	or  %i5, 0xa0, %o1                             
400283e8:	80 a2 20 00 	cmp  %o0, 0                                    
400283ec:	22 80 00 0d 	be,a   40028420 <init_etc_passwd_group+0x80>   
400283f0:	90 17 22 10 	or  %i4, 0x210, %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);                                                       
400283f4:	40 00 51 2f 	call  4003c8b0 <fclose>                        
400283f8:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Initialize /etc/group                                           
   */                                                                 
  if ((fp = fopen("/etc/group", "r")) != NULL) {                      
400283fc:	39 10 01 81 	sethi  %hi(0x40060400), %i4                    
40028400:	92 17 60 a0 	or  %i5, 0xa0, %o1                             
40028404:	40 00 53 89 	call  4003d228 <fopen>                         
40028408:	90 17 22 88 	or  %i4, 0x288, %o0                            
4002840c:	80 a2 20 00 	cmp  %o0, 0                                    
40028410:	22 80 00 11 	be,a   40028454 <init_etc_passwd_group+0xb4>   
40028414:	90 17 22 88 	or  %i4, 0x288, %o0                            
    fclose(fp);                                                       
40028418:	40 00 51 26 	call  4003c8b0 <fclose>                        
4002841c:	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) {                
40028420:	13 10 01 78 	sethi  %hi(0x4005e000), %o1                    
40028424:	40 00 53 81 	call  4003d228 <fopen>                         
40028428:	92 12 60 e8 	or  %o1, 0xe8, %o1	! 4005e0e8 <rtems_rtc_shell_usage+0x4e8>
4002842c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40028430:	02 bf ff f3 	be  400283fc <init_etc_passwd_group+0x5c>      <== NEVER TAKEN
40028434:	92 10 20 01 	mov  1, %o1                                    
    fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"                        
40028438:	94 10 20 66 	mov  0x66, %o2                                 
4002843c:	96 10 00 1c 	mov  %i4, %o3                                  
40028440:	11 10 01 81 	sethi  %hi(0x40060400), %o0                    
40028444:	40 00 58 48 	call  4003e564 <fwrite>                        
40028448:	90 12 22 20 	or  %o0, 0x220, %o0	! 40060620 <rtems_status_assoc+0x180>
                 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n"         
                 "tty:!:2:2:tty owner::/:/bin/false\n" );             
    fclose(fp);                                                       
4002844c:	10 bf ff ea 	b  400283f4 <init_etc_passwd_group+0x54>       
40028450:	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) {                 
40028454:	13 10 01 78 	sethi  %hi(0x4005e000), %o1                    
40028458:	40 00 53 74 	call  4003d228 <fopen>                         
4002845c:	92 12 60 e8 	or  %o1, 0xe8, %o1	! 4005e0e8 <rtems_rtc_shell_usage+0x4e8>
40028460:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40028464:	02 bf ff d5 	be  400283b8 <init_etc_passwd_group+0x18>      <== NEVER TAKEN
40028468:	92 10 20 01 	mov  1, %o1                                    
    fprintf( fp, "root:x:0:root\n"                                    
4002846c:	11 10 01 81 	sethi  %hi(0x40060400), %o0                    
40028470:	94 10 20 2a 	mov  0x2a, %o2                                 
40028474:	96 10 00 18 	mov  %i0, %o3                                  
40028478:	40 00 58 3b 	call  4003e564 <fwrite>                        
4002847c:	90 12 22 98 	or  %o0, 0x298, %o0                            
                 "rtems:x:1:rtems\n"                                  
                 "tty:x:2:tty\n" );                                   
    fclose(fp);                                                       
40028480:	40 00 51 0c 	call  4003c8b0 <fclose>                        
40028484:	81 e8 00 00 	restore                                        
                                                                      

40006e44 <iproc>: /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) {
40006e44:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (tty->termios.c_iflag & ISTRIP)                                  
40006e48:	c2 06 60 30 	ld  [ %i1 + 0x30 ], %g1                        
40006e4c:	80 88 60 20 	btst  0x20, %g1                                
40006e50:	32 80 00 02 	bne,a   40006e58 <iproc+0x14>                  <== NEVER TAKEN
40006e54:	b0 0e 20 7f 	and  %i0, 0x7f, %i0                            <== NOT EXECUTED
    c &= 0x7f;                                                        
                                                                      
  if (tty->termios.c_iflag & IUCLC)                                   
40006e58:	80 88 62 00 	btst  0x200, %g1                               
40006e5c:	02 80 00 0d 	be  40006e90 <iproc+0x4c>                      
40006e60:	80 a6 20 0d 	cmp  %i0, 0xd                                  
    c = tolower (c);                                                  
40006e64:	05 10 00 7d 	sethi  %hi(0x4001f400), %g2                    
40006e68:	c6 00 a3 60 	ld  [ %g2 + 0x360 ], %g3	! 4001f760 <__ctype_ptr__>
40006e6c:	84 10 00 18 	mov  %i0, %g2                                  
40006e70:	b0 00 c0 18 	add  %g3, %i0, %i0                             
40006e74:	c6 0e 20 01 	ldub  [ %i0 + 1 ], %g3                         
40006e78:	86 08 e0 03 	and  %g3, 3, %g3                               
40006e7c:	80 a0 e0 01 	cmp  %g3, 1                                    
40006e80:	22 80 00 02 	be,a   40006e88 <iproc+0x44>                   
40006e84:	84 00 a0 20 	add  %g2, 0x20, %g2                            
40006e88:	b0 08 a0 ff 	and  %g2, 0xff, %i0                            
                                                                      
  if (c == '\r') {                                                    
40006e8c:	80 a6 20 0d 	cmp  %i0, 0xd                                  
40006e90:	02 80 00 1d 	be  40006f04 <iproc+0xc0>                      
40006e94:	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)) {         
40006e98:	02 80 00 44 	be  40006fa8 <iproc+0x164>                     
40006e9c:	80 a6 20 00 	cmp  %i0, 0                                    
    c = '\r';                                                         
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
40006ea0:	32 80 00 1f 	bne,a   40006f1c <iproc+0xd8>                  <== ALWAYS TAKEN
40006ea4:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
  }                                                                   
                                                                      
  /*                                                                  
   * FIXME: Should do IMAXBEL handling somehow                        
   */                                                                 
  if (tty->ccount < (CBUFSIZE-1)) {                                   
40006ea8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
40006eac:	05 10 00 7d 	sethi  %hi(0x4001f400), %g2                    
40006eb0:	c4 00 a1 e8 	ld  [ %g2 + 0x1e8 ], %g2	! 4001f5e8 <rtems_termios_cbufsize>
40006eb4:	84 00 bf ff 	add  %g2, -1, %g2                              
40006eb8:	80 a0 40 02 	cmp  %g1, %g2                                  
40006ebc:	1a 80 00 10 	bcc  40006efc <iproc+0xb8>                     <== NEVER TAKEN
40006ec0:	01 00 00 00 	nop                                            
    if (tty->termios.c_lflag & ECHO)                                  
40006ec4:	c4 06 60 3c 	ld  [ %i1 + 0x3c ], %g2                        
40006ec8:	80 88 a0 08 	btst  8, %g2                                   
40006ecc:	12 80 00 3c 	bne  40006fbc <iproc+0x178>                    <== ALWAYS TAKEN
40006ed0:	84 00 60 01 	add  %g1, 1, %g2                               
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
40006ed4:	c6 06 60 1c 	ld  [ %i1 + 0x1c ], %g3                        <== NOT EXECUTED
40006ed8:	f0 28 c0 01 	stb  %i0, [ %g3 + %g1 ]                        <== NOT EXECUTED
40006edc:	c4 26 60 20 	st  %g2, [ %i1 + 0x20 ]                        <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
40006ee0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006ee4:	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)                                               
40006ee8:	80 a0 60 00 	cmp  %g1, 0                                    
40006eec:	02 80 00 04 	be  40006efc <iproc+0xb8>                      
40006ef0:	90 10 00 19 	mov  %i1, %o0                                  
40006ef4:	7f ff ff 5f 	call  40006c70 <erase.part.2>                  
40006ef8:	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;                                                       
40006efc:	81 c7 e0 08 	ret                                            
40006f00:	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)                                 
40006f04:	80 88 60 80 	btst  0x80, %g1                                
40006f08:	12 bf ff fd 	bne  40006efc <iproc+0xb8>                     <== NEVER TAKEN
40006f0c:	80 88 61 00 	btst  0x100, %g1                               
      return 0;                                                       
    if (tty->termios.c_iflag & ICRNL)                                 
40006f10:	32 80 00 02 	bne,a   40006f18 <iproc+0xd4>                  <== ALWAYS TAKEN
40006f14:	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)) {               
40006f18:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
40006f1c:	80 88 60 02 	btst  2, %g1                                   
40006f20:	22 bf ff e3 	be,a   40006eac <iproc+0x68>                   
40006f24:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
    if (c == tty->termios.c_cc[VERASE]) {                             
40006f28:	c4 0e 60 43 	ldub  [ %i1 + 0x43 ], %g2                      
40006f2c:	80 a0 80 18 	cmp  %g2, %i0                                  
40006f30:	22 bf ff ee 	be,a   40006ee8 <iproc+0xa4>                   
40006f34:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
      erase (tty, 0);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VKILL]) {                         
40006f38:	c4 0e 60 44 	ldub  [ %i1 + 0x44 ], %g2                      
40006f3c:	80 a0 80 18 	cmp  %g2, %i0                                  
40006f40:	22 80 00 2d 	be,a   40006ff4 <iproc+0x1b0>                  
40006f44:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
      erase (tty, 1);                                                 
      return 0;                                                       
    }                                                                 
    else if (c == tty->termios.c_cc[VEOF]) {                          
40006f48:	c4 0e 60 45 	ldub  [ %i1 + 0x45 ], %g2                      
40006f4c:	80 a0 80 18 	cmp  %g2, %i0                                  
40006f50:	02 80 00 42 	be  40007058 <iproc+0x214>                     <== NEVER TAKEN
40006f54:	80 a6 20 0a 	cmp  %i0, 0xa                                  
      return 1;                                                       
    } else if (c == '\n') {                                           
40006f58:	02 80 00 33 	be  40007024 <iproc+0x1e0>                     
40006f5c:	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]) ||                      
40006f60:	c4 0e 60 4c 	ldub  [ %i1 + 0x4c ], %g2                      
40006f64:	80 a0 80 18 	cmp  %g2, %i0                                  
40006f68:	02 80 00 07 	be  40006f84 <iproc+0x140>                     <== NEVER TAKEN
40006f6c:	80 88 60 08 	btst  8, %g1                                   
40006f70:	c4 0e 60 51 	ldub  [ %i1 + 0x51 ], %g2                      
40006f74:	80 a0 80 18 	cmp  %g2, %i0                                  
40006f78:	32 bf ff cd 	bne,a   40006eac <iproc+0x68>                  <== ALWAYS TAKEN
40006f7c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
               (c == tty->termios.c_cc[VEOL2])) {                     
      if (tty->termios.c_lflag & ECHO)                                
40006f80:	80 88 60 08 	btst  8, %g1                                   <== NOT EXECUTED
40006f84:	12 80 00 18 	bne  40006fe4 <iproc+0x1a0>                    <== NOT EXECUTED
40006f88:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
        echo (c, tty);                                                
      tty->cbuf[tty->ccount++] = c;                                   
40006f8c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
40006f90:	c6 06 60 1c 	ld  [ %i1 + 0x1c ], %g3                        <== NOT EXECUTED
40006f94:	84 00 60 01 	add  %g1, 1, %g2                               <== NOT EXECUTED
40006f98:	f0 28 c0 01 	stb  %i0, [ %g3 + %g1 ]                        <== NOT EXECUTED
40006f9c:	c4 26 60 20 	st  %g2, [ %i1 + 0x20 ]                        <== NOT EXECUTED
      return 1;                                                       
40006fa0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006fa4:	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)) {         
40006fa8:	80 88 60 40 	btst  0x40, %g1                                
40006fac:	32 bf ff db 	bne,a   40006f18 <iproc+0xd4>                  <== NEVER TAKEN
40006fb0:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
    c = '\r';                                                         
  }                                                                   
                                                                      
  if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {               
40006fb4:	10 bf ff da 	b  40006f1c <iproc+0xd8>                       
40006fb8:	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);                                                  
40006fbc:	90 10 00 18 	mov  %i0, %o0                                  
40006fc0:	7f ff ff 0b 	call  40006bec <echo>                          
40006fc4:	92 10 00 19 	mov  %i1, %o1                                  
40006fc8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
    tty->cbuf[tty->ccount++] = c;                                     
40006fcc:	c6 06 60 1c 	ld  [ %i1 + 0x1c ], %g3                        
40006fd0:	84 00 60 01 	add  %g1, 1, %g2                               
40006fd4:	f0 28 c0 01 	stb  %i0, [ %g3 + %g1 ]                        
40006fd8:	c4 26 60 20 	st  %g2, [ %i1 + 0x20 ]                        
  }                                                                   
  return 0;                                                           
40006fdc:	81 c7 e0 08 	ret                                            
40006fe0:	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);                                                
40006fe4:	7f ff ff 02 	call  40006bec <echo>                          <== NOT EXECUTED
40006fe8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
      tty->cbuf[tty->ccount++] = c;                                   
40006fec:	10 bf ff e9 	b  40006f90 <iproc+0x14c>                      <== NOT EXECUTED
40006ff0:	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)                                               
40006ff4:	80 a0 a0 00 	cmp  %g2, 0                                    
40006ff8:	02 bf ff c1 	be  40006efc <iproc+0xb8>                      <== NEVER TAKEN
40006ffc:	80 88 60 08 	btst  8, %g1                                   
    return;                                                           
  if (lineFlag) {                                                     
    if (!(tty->termios.c_lflag & ECHO)) {                             
40007000:	02 80 00 18 	be  40007060 <iproc+0x21c>                     <== NEVER TAKEN
40007004:	80 88 60 10 	btst  0x10, %g1                                
      tty->ccount = 0;                                                
      return;                                                         
    }                                                                 
    if (!(tty->termios.c_lflag & ECHOE)) {                            
40007008:	02 80 00 19 	be  4000706c <iproc+0x228>                     <== NEVER TAKEN
4000700c:	90 10 00 19 	mov  %i1, %o0                                  
40007010:	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;                                                       
40007014:	7f ff ff 17 	call  40006c70 <erase.part.2>                  
40007018:	b0 10 20 00 	clr  %i0                                       
4000701c:	81 c7 e0 08 	ret                                            
40007020:	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))                     
40007024:	22 80 00 06 	be,a   4000703c <iproc+0x1f8>                  <== NEVER TAKEN
40007028:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        <== NOT EXECUTED
        echo (c, tty);                                                
4000702c:	90 10 20 0a 	mov  0xa, %o0                                  
40007030:	7f ff fe ef 	call  40006bec <echo>                          
40007034:	92 10 00 19 	mov  %i1, %o1                                  
      tty->cbuf[tty->ccount++] = c;                                   
40007038:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
4000703c:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
40007040:	86 10 20 0a 	mov  0xa, %g3                                  
40007044:	c6 28 80 01 	stb  %g3, [ %g2 + %g1 ]                        
40007048:	82 00 60 01 	inc  %g1                                       
4000704c:	c2 26 60 20 	st  %g1, [ %i1 + 0x20 ]                        
      return 1;                                                       
40007050:	81 c7 e0 08 	ret                                            
40007054:	91 e8 20 01 	restore  %g0, 1, %o0                           
    if (tty->termios.c_lflag & ECHO)                                  
      echo (c, tty);                                                  
    tty->cbuf[tty->ccount++] = c;                                     
  }                                                                   
  return 0;                                                           
}                                                                     
40007058:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000705c:	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;                                                
40007060:	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;                                                       
40007064:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40007068:	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;                                                
4000706c:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            <== NOT EXECUTED
      echo (tty->termios.c_cc[VKILL], tty);                           
40007070:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40007074:	7f ff fe de 	call  40006bec <echo>                          <== NOT EXECUTED
40007078:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
      if (tty->termios.c_lflag & ECHOK)                               
4000707c:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        <== NOT EXECUTED
40007080:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
40007084:	02 bf ff 9e 	be  40006efc <iproc+0xb8>                      <== NOT EXECUTED
40007088:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
        echo ('\n', tty);                                             
4000708c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40007090:	7f ff fe d7 	call  40006bec <echo>                          <== NOT EXECUTED
40007094:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
40007098:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000709c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001cbb8 <killinfo>: int killinfo( pid_t pid, int sig, const union sigval *value ) {
4001cbb8:	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() )                                              
4001cbbc:	7f ff ff 10 	call  4001c7fc <getpid>                        
4001cbc0:	01 00 00 00 	nop                                            
4001cbc4:	80 a2 00 18 	cmp  %o0, %i0                                  
4001cbc8:	12 80 00 af 	bne  4001ce84 <killinfo+0x2cc>                 
4001cbcc:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( ESRCH );                    
                                                                      
  /*                                                                  
   *  Validate the signal passed.                                     
   */                                                                 
  if ( !sig )                                                         
4001cbd0:	02 80 00 b3 	be  4001ce9c <killinfo+0x2e4>                  
4001cbd4:	82 06 7f ff 	add  %i1, -1, %g1                              
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
4001cbd8:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
4001cbdc:	18 80 00 b0 	bgu  4001ce9c <killinfo+0x2e4>                 
4001cbe0:	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 )          
4001cbe4:	31 10 00 82 	sethi  %hi(0x40020800), %i0                    
4001cbe8:	a3 2e 60 04 	sll  %i1, 4, %l1                               
4001cbec:	b0 16 20 20 	or  %i0, 0x20, %i0                             
4001cbf0:	84 24 40 10 	sub  %l1, %l0, %g2                             
4001cbf4:	84 06 00 02 	add  %i0, %g2, %g2                             
4001cbf8:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
4001cbfc:	80 a0 a0 01 	cmp  %g2, 1                                    
4001cc00:	02 80 00 9f 	be  4001ce7c <killinfo+0x2c4>                  
4001cc04:	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 ) )      
4001cc08:	02 80 00 41 	be  4001cd0c <killinfo+0x154>                  
4001cc0c:	80 a6 60 08 	cmp  %i1, 8                                    
4001cc10:	02 80 00 3f 	be  4001cd0c <killinfo+0x154>                  
4001cc14:	80 a6 60 0b 	cmp  %i1, 0xb                                  
4001cc18:	02 80 00 3d 	be  4001cd0c <killinfo+0x154>                  
4001cc1c:	ba 10 20 01 	mov  1, %i5                                    
                                                                      
  /*                                                                  
   *  Build up a siginfo structure                                    
   */                                                                 
  siginfo = &siginfo_struct;                                          
  siginfo->si_signo = sig;                                            
4001cc20:	f2 27 bf f4 	st  %i1, [ %fp + -12 ]                         
  siginfo->si_code = SI_USER;                                         
4001cc24:	fa 27 bf f8 	st  %i5, [ %fp + -8 ]                          
  if ( !value ) {                                                     
4001cc28:	80 a6 a0 00 	cmp  %i2, 0                                    
4001cc2c:	02 80 00 3e 	be  4001cd24 <killinfo+0x16c>                  
4001cc30:	bb 2f 40 01 	sll  %i5, %g1, %i5                             
    siginfo->si_value.sival_int = 0;                                  
  } else {                                                            
    siginfo->si_value = *value;                                       
4001cc34:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4001cc38:	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;                  
4001cc3c:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4001cc40:	c4 00 62 b0 	ld  [ %g1 + 0x2b0 ], %g2	! 400202b0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
4001cc44:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
4001cc48:	c4 20 62 b0 	st  %g2, [ %g1 + 0x2b0 ]                       
 */                                                                   
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 );     
4001cc4c:	11 10 00 7d 	sethi  %hi(0x4001f400), %o0                    
4001cc50:	7f ff b0 ca 	call  40008f78 <_API_extensions_Add_post_switch>
4001cc54:	90 12 22 ac 	or  %o0, 0x2ac, %o0	! 4001f6ac <_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;                                     
4001cc58:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
4001cc5c:	d0 00 63 d0 	ld  [ %g1 + 0x3d0 ], %o0	! 400207d0 <_Per_CPU_Information+0x10>
                                                                      
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
  if ( _POSIX_signals_Is_interested( api, mask ) ) {                  
4001cc60:	c2 02 21 50 	ld  [ %o0 + 0x150 ], %g1                       
4001cc64:	c2 00 60 d0 	ld  [ %g1 + 0xd0 ], %g1                        
4001cc68:	80 af 40 01 	andncc  %i5, %g1, %g0                          
4001cc6c:	12 80 00 17 	bne  4001ccc8 <killinfo+0x110>                 
4001cc70:	09 10 00 82 	sethi  %hi(0x40020800), %g4                    
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4001cc74:	c2 01 21 ac 	ld  [ %g4 + 0x1ac ], %g1	! 400209ac <_POSIX_signals_Wait_queue>
4001cc78:	88 11 21 ac 	or  %g4, 0x1ac, %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 );                         
4001cc7c:	88 01 20 04 	add  %g4, 4, %g4                               
4001cc80:	80 a0 40 04 	cmp  %g1, %g4                                  
4001cc84:	32 80 00 0d 	bne,a   4001ccb8 <killinfo+0x100>              
4001cc88:	c4 00 60 30 	ld  [ %g1 + 0x30 ], %g2                        
   *  NOTES:                                                          
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
  interested_priority = PRIORITY_MAXIMUM + 1;                         
4001cc8c:	10 80 00 28 	b  4001cd2c <killinfo+0x174>                   
4001cc90:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
                                                                      
    /*                                                                
     * Is this thread is blocked waiting for another signal but has   
     * not blocked this one?                                          
     */                                                               
    if (~api->signals_blocked & mask)                                 
4001cc94:	c4 00 e0 d0 	ld  [ %g3 + 0xd0 ], %g2                        
4001cc98:	80 af 40 02 	andncc  %i5, %g2, %g0                          
4001cc9c:	12 80 00 0b 	bne  4001ccc8 <killinfo+0x110>                 
4001cca0:	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 ) {                                 
4001cca4:	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 );                         
4001cca8:	80 a0 40 04 	cmp  %g1, %g4                                  
4001ccac:	22 80 00 20 	be,a   4001cd2c <killinfo+0x174>               <== ALWAYS TAKEN
4001ccb0:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
    #endif                                                            
                                                                      
    /*                                                                
     * Is this thread is actually blocked waiting for the signal?     
     */                                                               
    if (the_thread->Wait.option & mask)                               
4001ccb4:	c4 00 60 30 	ld  [ %g1 + 0x30 ], %g2	! 4001f430 <__clz_tab+0xc8><== NOT EXECUTED
4001ccb8:	80 8f 40 02 	btst  %i5, %g2                                 
4001ccbc:	02 bf ff f6 	be  4001cc94 <killinfo+0xdc>                   
4001ccc0:	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 ) {                                 
4001ccc4:	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 ) ) {  
4001ccc8:	92 10 00 19 	mov  %i1, %o1                                  
4001cccc:	40 00 00 8b 	call  4001cef8 <_POSIX_signals_Unblock_thread> 
4001ccd0:	94 07 bf f4 	add  %fp, -12, %o2                             
4001ccd4:	80 8a 20 ff 	btst  0xff, %o0                                
4001ccd8:	12 80 00 09 	bne  4001ccfc <killinfo+0x144>                 
4001ccdc:	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 );                         
4001cce0:	40 00 00 7d 	call  4001ced4 <_POSIX_signals_Set_process_signals>
4001cce4:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {       
4001cce8:	a0 24 40 10 	sub  %l1, %l0, %l0                             
4001ccec:	c2 06 00 10 	ld  [ %i0 + %l0 ], %g1                         
4001ccf0:	80 a0 60 02 	cmp  %g1, 2                                    
4001ccf4:	02 80 00 4f 	be  4001ce30 <killinfo+0x278>                  
4001ccf8:	11 10 00 82 	sethi  %hi(0x40020800), %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();                                        
4001ccfc:	7f ff b8 f3 	call  4000b0c8 <_Thread_Enable_dispatch>       
4001cd00:	b0 10 20 00 	clr  %i0                                       
4001cd04:	81 c7 e0 08 	ret                                            
4001cd08:	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 );                     
4001cd0c:	40 00 01 13 	call  4001d158 <pthread_self>                  
4001cd10:	01 00 00 00 	nop                                            
4001cd14:	40 00 00 d2 	call  4001d05c <pthread_kill>                  
4001cd18:	92 10 00 19 	mov  %i1, %o1                                  
4001cd1c:	81 c7 e0 08 	ret                                            
4001cd20:	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;                                  
4001cd24:	10 bf ff c6 	b  4001cc3c <killinfo+0x84>                    
4001cd28:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
   *  NOTES:                                                          
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
  interested_priority = PRIORITY_MAXIMUM + 1;                         
4001cd2c:	f8 08 60 dc 	ldub  [ %g1 + 0xdc ], %i4                      
4001cd30:	1b 10 00 80 	sethi  %hi(0x40020000), %o5                    
4001cd34:	b8 07 20 01 	inc  %i4                                       
4001cd38:	9a 13 62 1c 	or  %o5, 0x21c, %o5                            
   *                                                                  
   *  NOTES:                                                          
   *                                                                  
   *    + rtems internal threads do not receive signals.              
   */                                                                 
  interested = NULL;                                                  
4001cd3c:	90 10 20 00 	clr  %o0                                       
 */                                                                   
                                                                      
#define _POSIX_signals_Is_interested( _api, _mask ) \                 
  ( ~(_api)->signals_blocked & (_mask) )                              
                                                                      
int killinfo(                                                         
4001cd40:	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);              
4001cd44:	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 ] )                     
4001cd48:	c2 03 40 00 	ld  [ %o5 ], %g1                               
4001cd4c:	80 a0 60 00 	cmp  %g1, 0                                    
4001cd50:	22 80 00 31 	be,a   4001ce14 <killinfo+0x25c>               <== NEVER TAKEN
4001cd54:	9a 03 60 04 	add  %o5, 4, %o5                               <== NOT EXECUTED
      continue;                                                       
                                                                      
    the_info = _Objects_Information_table[ the_api ][ 1 ];            
4001cd58:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
       */                                                             
      if ( !the_info )                                                
        continue;                                                     
    #endif                                                            
                                                                      
    maximum = the_info->maximum;                                      
4001cd5c:	f6 10 60 10 	lduh  [ %g1 + 0x10 ], %i3                      
    object_table = the_info->local_table;                             
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
4001cd60:	80 a6 e0 00 	cmp  %i3, 0                                    
4001cd64:	02 80 00 2b 	be  4001ce10 <killinfo+0x258>                  
4001cd68:	f4 00 60 1c 	ld  [ %g1 + 0x1c ], %i2                        
4001cd6c:	84 10 20 01 	mov  1, %g2                                    
 */                                                                   
                                                                      
#define _POSIX_signals_Is_interested( _api, _mask ) \                 
  ( ~(_api)->signals_blocked & (_mask) )                              
                                                                      
int killinfo(                                                         
4001cd70:	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 ];          
4001cd74:	c6 06 80 03 	ld  [ %i2 + %g3 ], %g3                         
                                                                      
      if ( !the_thread )                                              
4001cd78:	80 a0 e0 00 	cmp  %g3, 0                                    
4001cd7c:	22 80 00 22 	be,a   4001ce04 <killinfo+0x24c>               
4001cd80:	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 )       
4001cd84:	c8 00 e0 14 	ld  [ %g3 + 0x14 ], %g4                        
4001cd88:	80 a1 00 1c 	cmp  %g4, %i4                                  
4001cd8c:	38 80 00 1e 	bgu,a   4001ce04 <killinfo+0x24c>              
4001cd90:	84 00 a0 01 	inc  %g2                                       
      #if defined(RTEMS_DEBUG)                                        
        if ( !api )                                                   
          continue;                                                   
      #endif                                                          
                                                                      
      if ( !_POSIX_signals_Is_interested( api, mask ) )               
4001cd94:	de 00 e1 50 	ld  [ %g3 + 0x150 ], %o7                       
4001cd98:	de 03 e0 d0 	ld  [ %o7 + 0xd0 ], %o7                        
4001cd9c:	80 af 40 0f 	andncc  %i5, %o7, %g0                          
4001cda0:	22 80 00 19 	be,a   4001ce04 <killinfo+0x24c>               
4001cda4:	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 ) {     
4001cda8:	80 a1 00 1c 	cmp  %g4, %i4                                  
4001cdac:	2a 80 00 14 	bcs,a   4001cdfc <killinfo+0x244>              
4001cdb0:	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 ) ) {
4001cdb4:	80 a2 20 00 	cmp  %o0, 0                                    
4001cdb8:	22 80 00 13 	be,a   4001ce04 <killinfo+0x24c>               <== NEVER TAKEN
4001cdbc:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
4001cdc0:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
4001cdc4:	80 a0 60 00 	cmp  %g1, 0                                    
4001cdc8:	22 80 00 0f 	be,a   4001ce04 <killinfo+0x24c>               <== NEVER TAKEN
4001cdcc:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
        /* preferred ready over blocked */                            
        DEBUG_STEP("5");                                              
        if ( _States_Is_ready( the_thread->current_state ) ) {        
4001cdd0:	de 00 e0 10 	ld  [ %g3 + 0x10 ], %o7                        
4001cdd4:	80 a3 e0 00 	cmp  %o7, 0                                    
4001cdd8:	22 80 00 09 	be,a   4001cdfc <killinfo+0x244>               
4001cddc:	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) ) {
4001cde0:	80 88 40 0b 	btst  %g1, %o3                                 
4001cde4:	32 80 00 08 	bne,a   4001ce04 <killinfo+0x24c>              
4001cde8:	84 00 a0 01 	inc  %g2                                       
          DEBUG_STEP("7");                                            
          if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
4001cdec:	80 8b c0 0b 	btst  %o7, %o3                                 
4001cdf0:	22 80 00 05 	be,a   4001ce04 <killinfo+0x24c>               
4001cdf4:	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 ) ) {        
4001cdf8:	b8 10 00 04 	mov  %g4, %i4                                  
4001cdfc:	90 10 00 03 	mov  %g3, %o0                                  
    #endif                                                            
                                                                      
    maximum = the_info->maximum;                                      
    object_table = the_info->local_table;                             
                                                                      
    for ( index = 1 ; index <= maximum ; index++ ) {                  
4001ce00:	84 00 a0 01 	inc  %g2                                       
4001ce04:	80 a6 c0 02 	cmp  %i3, %g2                                  
4001ce08:	1a bf ff db 	bcc  4001cd74 <killinfo+0x1bc>                 
4001ce0c:	87 28 a0 02 	sll  %g2, 2, %g3                               
4001ce10:	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++) {
4001ce14:	80 a3 40 0c 	cmp  %o5, %o4                                  
4001ce18:	32 bf ff cd 	bne,a   4001cd4c <killinfo+0x194>              
4001ce1c:	c2 03 40 00 	ld  [ %o5 ], %g1                               
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( interested ) {                                                 
4001ce20:	80 a2 20 00 	cmp  %o0, 0                                    
4001ce24:	12 bf ff aa 	bne  4001cccc <killinfo+0x114>                 
4001ce28:	92 10 00 19 	mov  %i1, %o1                                  
4001ce2c:	30 bf ff ad 	b,a   4001cce0 <killinfo+0x128>                
   */                                                                 
  _POSIX_signals_Set_process_signals( mask );                         
                                                                      
  if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {       
                                                                      
    psiginfo = (POSIX_signals_Siginfo_node *)                         
4001ce30:	7f ff b0 b7 	call  4000910c <_Chain_Get>                    
4001ce34:	90 12 21 a0 	or  %o0, 0x1a0, %o0                            
               _Chain_Get( &_POSIX_signals_Inactive_siginfo );        
    if ( !psiginfo ) {                                                
4001ce38:	92 92 20 00 	orcc  %o0, 0, %o1                              
4001ce3c:	02 80 00 1e 	be  4001ceb4 <killinfo+0x2fc>                  
4001ce40:	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 ); 
4001ce44:	11 10 00 82 	sethi  %hi(0x40020800), %o0                    
    if ( !psiginfo ) {                                                
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
    }                                                                 
                                                                      
    psiginfo->Info = *siginfo;                                        
4001ce48:	c2 22 60 08 	st  %g1, [ %o1 + 8 ]                           
4001ce4c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                                                                      
    _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 
4001ce50:	90 12 22 18 	or  %o0, 0x218, %o0                            
    if ( !psiginfo ) {                                                
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
    }                                                                 
                                                                      
    psiginfo->Info = *siginfo;                                        
4001ce54:	c2 22 60 0c 	st  %g1, [ %o1 + 0xc ]                         
4001ce58:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
    _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 
4001ce5c:	90 02 00 10 	add  %o0, %l0, %o0                             
    if ( !psiginfo ) {                                                
      _Thread_Enable_dispatch();                                      
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
    }                                                                 
                                                                      
    psiginfo->Info = *siginfo;                                        
4001ce60:	c2 22 60 10 	st  %g1, [ %o1 + 0x10 ]                        
                                                                      
    _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 
4001ce64:	7f ff b0 9f 	call  400090e0 <_Chain_Append>                 
4001ce68:	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();                                        
4001ce6c:	7f ff b8 97 	call  4000b0c8 <_Thread_Enable_dispatch>       
4001ce70:	01 00 00 00 	nop                                            
4001ce74:	81 c7 e0 08 	ret                                            
4001ce78:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  DEBUG_STEP("\n");                                                   
  _Thread_Enable_dispatch();                                          
  return 0;                                                           
}                                                                     
4001ce7c:	81 c7 e0 08 	ret                                            
4001ce80:	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 );                    
4001ce84:	7f ff ce af 	call  40010940 <__errno>                       
4001ce88:	b0 10 3f ff 	mov  -1, %i0                                   
4001ce8c:	82 10 20 03 	mov  3, %g1                                    
4001ce90:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001ce94:	81 c7 e0 08 	ret                                            
4001ce98:	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 );                   
4001ce9c:	7f ff ce a9 	call  40010940 <__errno>                       
4001cea0:	b0 10 3f ff 	mov  -1, %i0                                   
4001cea4:	82 10 20 16 	mov  0x16, %g1                                 
4001cea8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001ceac:	81 c7 e0 08 	ret                                            
4001ceb0:	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();                                      
4001ceb4:	7f ff b8 85 	call  4000b0c8 <_Thread_Enable_dispatch>       
4001ceb8:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one( EAGAIN );                 
4001cebc:	7f ff ce a1 	call  40010940 <__errno>                       
4001cec0:	01 00 00 00 	nop                                            
4001cec4:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
4001cec8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001cecc:	81 c7 e0 08 	ret                                            
4001ced0:	81 e8 00 00 	restore                                        
                                                                      

40004ad4 <libc_wrapup>: extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) {
40004ad4:	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()))                      
40004ad8:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
40004adc:	c2 00 63 b8 	ld  [ %g1 + 0x3b8 ], %g1	! 400207b8 <_System_state_Current>
40004ae0:	80 a0 60 03 	cmp  %g1, 3                                    
40004ae4:	02 80 00 04 	be  40004af4 <libc_wrapup+0x20>                <== ALWAYS TAKEN
40004ae8:	3b 10 00 7d 	sethi  %hi(0x4001f400), %i5                    
40004aec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004af0:	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) {                                 
40004af4:	05 10 00 7a 	sethi  %hi(0x4001e800), %g2                    
40004af8:	c2 07 63 68 	ld  [ %i5 + 0x368 ], %g1                       
40004afc:	f8 00 a2 a8 	ld  [ %g2 + 0x2a8 ], %i4                       
40004b00:	80 a0 40 1c 	cmp  %g1, %i4                                  
40004b04:	02 80 00 05 	be  40004b18 <libc_wrapup+0x44>                
40004b08:	01 00 00 00 	nop                                            
      _wrapup_reent(_global_impure_ptr);                              
40004b0c:	40 00 32 bc 	call  400115fc <_wrapup_reent>                 
40004b10:	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;                                    
40004b14:	f8 27 63 68 	st  %i4, [ %i5 + 0x368 ]                       
   *                                                                  
   * Should this be changed to do *all* file streams?                 
   *    _fwalk (_REENT, fclose);                                      
   */                                                                 
                                                                      
  fclose (stdin);                                                     
40004b18:	40 00 2f dc 	call  40010a88 <fclose>                        
40004b1c:	d0 07 20 04 	ld  [ %i4 + 4 ], %o0                           
  fclose (stdout);                                                    
40004b20:	c2 07 63 68 	ld  [ %i5 + 0x368 ], %g1                       
40004b24:	40 00 2f d9 	call  40010a88 <fclose>                        
40004b28:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
  fclose (stderr);                                                    
40004b2c:	c2 07 63 68 	ld  [ %i5 + 0x368 ], %g1                       
40004b30:	f0 00 60 0c 	ld  [ %g1 + 0xc ], %i0                         
40004b34:	40 00 2f d5 	call  40010a88 <fclose>                        
40004b38:	81 e8 00 00 	restore                                        
                                                                      

40004570 <malloc>: #include "malloc_p.h" void *malloc( size_t size ) {
40004570:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void        *return_this;                                           
                                                                      
  MSBUMP(malloc_calls, 1);                                            
40004574:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
40004578:	82 10 61 30 	or  %g1, 0x130, %g1	! 40020130 <rtems_malloc_statistics>
4000457c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40004580:	84 00 a0 01 	inc  %g2                                       
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
40004584:	7f ff ff b8 	call  40004464 <malloc_deferred_frees_process> 
40004588:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
                                                                      
  /*                                                                  
   * Validate the parameters                                          
   */                                                                 
  if ( !size )                                                        
4000458c:	80 a6 20 00 	cmp  %i0, 0                                    
40004590:	02 80 00 25 	be  40004624 <malloc+0xb4>                     
40004594:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
    return (void *) 0;                                                
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
40004598:	c2 00 63 b8 	ld  [ %g1 + 0x3b8 ], %g1	! 400207b8 <_System_state_Current>
4000459c:	80 a0 60 03 	cmp  %g1, 3                                    
400045a0:	02 80 00 1c 	be  40004610 <malloc+0xa0>                     
400045a4:	39 10 00 7d 	sethi  %hi(0x4001f400), %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 );
400045a8:	d0 07 21 60 	ld  [ %i4 + 0x160 ], %o0	! 4001f560 <RTEMS_Malloc_Heap>
400045ac:	92 10 00 18 	mov  %i0, %o1                                  
400045b0:	94 10 20 00 	clr  %o2                                       
400045b4:	40 00 17 ac 	call  4000a464 <_Protected_heap_Allocate_aligned_with_boundary>
400045b8:	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 ) {                                               
400045bc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400045c0:	02 80 00 1c 	be  40004630 <malloc+0xc0>                     
400045c4:	d0 07 21 60 	ld  [ %i4 + 0x160 ], %o0                       
  }                                                                   
                                                                      
  /*                                                                  
   *  If the user wants us to dirty the allocated memory, then do it. 
   */                                                                 
  if ( rtems_malloc_dirty_helper )                                    
400045c8:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
400045cc:	c2 00 60 8c 	ld  [ %g1 + 0x8c ], %g1	! 4001fc8c <rtems_malloc_dirty_helper>
400045d0:	80 a0 60 00 	cmp  %g1, 0                                    
400045d4:	02 80 00 04 	be  400045e4 <malloc+0x74>                     
400045d8:	90 10 00 1d 	mov  %i5, %o0                                  
    (*rtems_malloc_dirty_helper)( return_this, size );                
400045dc:	9f c0 40 00 	call  %g1                                      
400045e0:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
  /*                                                                  
   *  If configured, update the statistics                            
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
400045e4:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
400045e8:	c2 00 60 90 	ld  [ %g1 + 0x90 ], %g1	! 4001fc90 <rtems_malloc_statistics_helpers>
400045ec:	80 a0 60 00 	cmp  %g1, 0                                    
400045f0:	22 80 00 06 	be,a   40004608 <malloc+0x98>                  
400045f4:	b0 10 00 1d 	mov  %i5, %i0                                  
    (*rtems_malloc_statistics_helpers->at_malloc)(return_this);       
400045f8:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
400045fc:	9f c0 40 00 	call  %g1                                      
40004600:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  return return_this;                                                 
}                                                                     
40004604:	b0 10 00 1d 	mov  %i5, %i0                                  
40004608:	81 c7 e0 08 	ret                                            
4000460c:	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() )                                 
40004610:	7f ff ff 88 	call  40004430 <malloc_is_system_state_OK>     
40004614:	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()) &&                    
40004618:	80 8a 20 ff 	btst  0xff, %o0                                
4000461c:	12 bf ff e3 	bne  400045a8 <malloc+0x38>                    <== ALWAYS TAKEN
40004620:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * Validate the parameters                                          
   */                                                                 
  if ( !size )                                                        
    return (void *) 0;                                                
40004624:	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;                                                 
}                                                                     
40004628:	81 c7 e0 08 	ret                                            
4000462c:	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 );
40004630:	03 10 00 75 	sethi  %hi(0x4001d400), %g1                    
40004634:	c2 00 62 60 	ld  [ %g1 + 0x260 ], %g1	! 4001d660 <rtems_malloc_extend_handler>
40004638:	9f c0 40 00 	call  %g1                                      
4000463c:	92 10 00 18 	mov  %i0, %o1                                  
    if ( !return_this ) {                                             
40004640:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40004644:	12 bf ff e2 	bne  400045cc <malloc+0x5c>                    <== NEVER TAKEN
40004648:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
      errno = ENOMEM;                                                 
4000464c:	40 00 30 bd 	call  40010940 <__errno>                       
40004650:	b0 10 00 1d 	mov  %i5, %i0                                  
40004654:	82 10 20 0c 	mov  0xc, %g1                                  
40004658:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000465c:	81 c7 e0 08 	ret                                            
40004660:	81 e8 00 00 	restore                                        
                                                                      

4000eecc <memfile_alloc_block>: * Allocate a block for an in-memory file. */ int memfile_blocks_allocated = 0; void *memfile_alloc_block(void) {
4000eecc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *memory;                                                       
                                                                      
  memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);           
4000eed0:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
4000eed4:	d2 00 61 28 	ld  [ %g1 + 0x128 ], %o1	! 4001fd28 <imfs_memfile_bytes_per_block>
4000eed8:	7f ff d4 1d 	call  40003f4c <calloc>                        
4000eedc:	90 10 20 01 	mov  1, %o0                                    
  if ( memory )                                                       
4000eee0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000eee4:	02 80 00 05 	be  4000eef8 <memfile_alloc_block+0x2c>        <== NEVER TAKEN
4000eee8:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
    memfile_blocks_allocated++;                                       
4000eeec:	c4 00 62 3c 	ld  [ %g1 + 0x23c ], %g2	! 4001fe3c <memfile_blocks_allocated>
4000eef0:	84 00 a0 01 	inc  %g2                                       
4000eef4:	c4 20 62 3c 	st  %g2, [ %g1 + 0x23c ]                       
                                                                      
  return memory;                                                      
}                                                                     
4000eef8:	81 c7 e0 08 	ret                                            
4000eefc:	81 e8 00 00 	restore                                        
                                                                      

4000f444 <memfile_free_blocks_in_table>: */ static void memfile_free_blocks_in_table( block_p **block_table, int entries ) {
4000f444:	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++ ) {                                     
4000f448:	80 a6 60 00 	cmp  %i1, 0                                    
4000f44c:	04 80 00 0f 	ble  4000f488 <memfile_free_blocks_in_table+0x44><== NEVER TAKEN
4000f450:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000f454:	ba 10 00 08 	mov  %o0, %i5                                  
4000f458:	b8 10 20 00 	clr  %i4                                       
    if ( b[i] ) {                                                     
4000f45c:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000f460:	80 a2 20 00 	cmp  %o0, 0                                    
4000f464:	02 80 00 05 	be  4000f478 <memfile_free_blocks_in_table+0x34>
4000f468:	b8 07 20 01 	inc  %i4                                       
      memfile_free_block( b[i] );                                     
4000f46c:	7f ff ff ed 	call  4000f420 <memfile_free_block>            
4000f470:	01 00 00 00 	nop                                            
      b[i] = 0;                                                       
4000f474:	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++ ) {                                     
4000f478:	80 a7 00 19 	cmp  %i4, %i1                                  
4000f47c:	12 bf ff f8 	bne  4000f45c <memfile_free_blocks_in_table+0x18>
4000f480:	ba 07 60 04 	add  %i5, 4, %i5                               
4000f484:	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 );                                 
4000f488:	7f ff ff e6 	call  4000f420 <memfile_free_block>            
4000f48c:	01 00 00 00 	nop                                            
  *block_table = 0;                                                   
4000f490:	c0 26 00 00 	clr  [ %i0 ]                                   
4000f494:	81 c7 e0 08 	ret                                            
4000f498:	81 e8 00 00 	restore                                        
                                                                      

4000fad8 <memfile_ftruncate>: int memfile_ftruncate( rtems_libio_t *iop, off_t length ) {
4000fad8:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  IMFS_jnode_t   *the_jnode;                                          
                                                                      
  the_jnode = iop->pathinfo.node_access;                              
4000fadc:	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 )                           
4000fae0:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        <== NOT EXECUTED
4000fae4:	80 a0 40 19 	cmp  %g1, %i1                                  <== NOT EXECUTED
4000fae8:	06 80 00 11 	bl  4000fb2c <memfile_ftruncate+0x54>          <== NOT EXECUTED
4000faec:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4000faf0:	22 80 00 0b 	be,a   4000fb1c <memfile_ftruncate+0x44>       <== NOT EXECUTED
4000faf4:	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;                                 
4000faf8:	f2 27 60 50 	st  %i1, [ %i5 + 0x50 ]                        <== NOT EXECUTED
4000fafc:	f4 27 60 54 	st  %i2, [ %i5 + 0x54 ]                        <== NOT EXECUTED
                                                                      
  IMFS_update_atime( the_jnode );                                     
4000fb00:	90 07 bf f8 	add  %fp, -8, %o0                              <== NOT EXECUTED
4000fb04:	7f ff d1 eb 	call  400042b0 <gettimeofday>                  <== NOT EXECUTED
4000fb08:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000fb0c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          <== NOT EXECUTED
4000fb10:	c2 27 60 40 	st  %g1, [ %i5 + 0x40 ]                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
4000fb14:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fb18:	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 )                           
4000fb1c:	80 a0 40 1a 	cmp  %g1, %i2                                  <== NOT EXECUTED
4000fb20:	3a bf ff f7 	bcc,a   4000fafc <memfile_ftruncate+0x24>      <== NOT EXECUTED
4000fb24:	f2 27 60 50 	st  %i1, [ %i5 + 0x50 ]                        <== NOT EXECUTED
    return IMFS_memfile_extend( the_jnode, true, length );            
4000fb28:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4000fb2c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4000fb30:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
4000fb34:	7f ff fe c4 	call  4000f644 <IMFS_memfile_extend>           <== NOT EXECUTED
4000fb38:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
4000fb3c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fb40:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

4000fa5c <memfile_open>: rtems_libio_t *iop, const char *pathname, int oflag, mode_t mode ) {
4000fa5c:	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)                                
4000fa60:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4000fa64:	80 88 60 04 	btst  4, %g1                                   
4000fa68:	02 80 00 07 	be  4000fa84 <memfile_open+0x28>               
4000fa6c:	d0 06 20 1c 	ld  [ %i0 + 0x1c ], %o0                        
4000fa70:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
   && (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {                 
4000fa74:	c2 00 40 00 	ld  [ %g1 ], %g1                               
4000fa78:	80 a0 60 05 	cmp  %g1, 5                                    
4000fa7c:	22 80 00 04 	be,a   4000fa8c <memfile_open+0x30>            <== NEVER TAKEN
4000fa80:	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;                                                           
4000fa84:	81 c7 e0 08 	ret                                            
4000fa88:	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;  
4000fa8c:	d6 02 20 58 	ld  [ %o0 + 0x58 ], %o3                        <== NOT EXECUTED
                                                                      
    the_jnode->control = &IMFS_node_control_memfile;                  
4000fa90:	03 10 00 79 	sethi  %hi(0x4001e400), %g1                    <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
4000fa94:	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;                  
4000fa98:	82 10 60 d4 	or  %g1, 0xd4, %g1                             <== NOT EXECUTED
    the_jnode->info.file.size            = 0;                         
4000fa9c:	c0 22 20 54 	clr  [ %o0 + 0x54 ]                            <== NOT EXECUTED
    the_jnode->info.file.indirect        = 0;                         
4000faa0:	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;                  
4000faa4:	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;                         
4000faa8:	c0 22 20 5c 	clr  [ %o0 + 0x5c ]                            <== NOT EXECUTED
    the_jnode->info.file.triply_indirect = 0;                         
    if ((count != 0)                                                  
4000faac:	80 a3 20 00 	cmp  %o4, 0                                    <== NOT EXECUTED
4000fab0:	02 bf ff f5 	be  4000fa84 <memfile_open+0x28>               <== NOT EXECUTED
4000fab4:	c0 22 20 60 	clr  [ %o0 + 0x60 ]                            <== NOT EXECUTED
     && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))      
4000fab8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000fabc:	7f ff ff 53 	call  4000f808 <IMFS_memfile_write>            <== NOT EXECUTED
4000fac0:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
        return -1;                                                    
4000fac4:	90 38 00 08 	xnor  %g0, %o0, %o0                            <== NOT EXECUTED
4000fac8:	80 a0 00 08 	cmp  %g0, %o0                                  <== NOT EXECUTED
4000facc:	b0 40 3f ff 	addx  %g0, -1, %i0                             <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4000fad0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fad4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40004788 <mount>: const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) {
40004788:	9d e3 bf 50 	save  %sp, -176, %sp                           
  int rv = 0;                                                         
                                                                      
  if (                                                                
4000478c:	80 a6 e0 01 	cmp  %i3, 1                                    
40004790:	18 80 00 9a 	bgu  400049f8 <mount+0x270>                    
40004794:	01 00 00 00 	nop                                            
    options == RTEMS_FILESYSTEM_READ_ONLY                             
      || options == RTEMS_FILESYSTEM_READ_WRITE                       
  ) {                                                                 
    rtems_filesystem_fsmount_me_t fsmount_me_h =                      
40004798:	40 00 22 e5 	call  4000d32c <rtems_filesystem_get_mount_handler>
4000479c:	90 10 00 1a 	mov  %i2, %o0                                  
      rtems_filesystem_get_mount_handler( filesystemtype );           
                                                                      
    if ( fsmount_me_h != NULL ) {                                     
400047a0:	a4 92 20 00 	orcc  %o0, 0, %l2                              
400047a4:	02 80 00 95 	be  400049f8 <mount+0x270>                     
400047a8:	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 : "/"; 
400047ac:	02 80 00 7b 	be  40004998 <mount+0x210>                     
400047b0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
                                                                      
int mount(                                                            
400047b4:	40 00 35 c8 	call  40011ed4 <strlen>                        
400047b8:	90 10 00 19 	mov  %i1, %o0                                  
400047bc:	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;          
400047c0:	40 00 35 c5 	call  40011ed4 <strlen>                        
400047c4:	90 10 00 1a 	mov  %i2, %o0                                  
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
                                                                      
int mount(                                                            
400047c8:	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;          
400047cc:	ba 10 00 08 	mov  %o0, %i5                                  
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
400047d0:	80 a6 20 00 	cmp  %i0, 0                                    
400047d4:	02 80 00 7a 	be  400049bc <mount+0x234>                     
400047d8:	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                 
400047dc:	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;                                 
400047e0:	40 00 35 bd 	call  40011ed4 <strlen>                        
400047e4:	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                 
400047e8:	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;                                 
400047ec:	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 ); 
400047f0:	90 10 20 01 	mov  1, %o0                                    
400047f4:	7f ff fd d6 	call  40003f4c <calloc>                        
400047f8:	92 02 40 11 	add  %o1, %l1, %o1                             
                                                                      
  if ( mt_entry != NULL ) {                                           
400047fc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40004800:	02 80 00 78 	be  400049e0 <mount+0x258>                     <== NEVER TAKEN
40004804:	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 );               
40004808:	92 10 00 1a 	mov  %i2, %o1                                  
4000480c:	90 10 00 10 	mov  %l0, %o0                                  
40004810:	40 00 32 9d 	call  40011284 <memcpy>                        
40004814:	94 10 00 14 	mov  %l4, %o2                                  
    mt_entry->type = str;                                             
40004818:	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 =                  
4000481c:	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 ) {                                   
40004820:	80 a6 20 00 	cmp  %i0, 0                                    
40004824:	02 80 00 08 	be  40004844 <mount+0xbc>                      
40004828:	b4 04 00 14 	add  %l0, %l4, %i2                             
      memcpy( str, source_or_null, source_size );                     
4000482c:	90 10 00 1a 	mov  %i2, %o0                                  
40004830:	92 10 00 18 	mov  %i0, %o1                                  
40004834:	40 00 32 94 	call  40011284 <memcpy>                        
40004838:	94 10 00 11 	mov  %l1, %o2                                  
      mt_entry->dev = str;                                            
4000483c:	f4 27 60 38 	st  %i2, [ %i5 + 0x38 ]                        
      str += source_size;                                             
40004840:	b4 06 80 11 	add  %i2, %l1, %i2                             
    }                                                                 
                                                                      
    memcpy( str, target, target_size );                               
40004844:	92 10 00 15 	mov  %l5, %o1                                  
40004848:	94 10 00 13 	mov  %l3, %o2                                  
4000484c:	40 00 32 8e 	call  40011284 <memcpy>                        
40004850:	90 10 00 1a 	mov  %i2, %o0                                  
    mt_entry->target = str;                                           
    str += target_size;                                               
                                                                      
    mt_entry->mounted = true;                                         
40004854:	82 10 20 01 	mov  1, %g1                                    
40004858:	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;
4000485c:	03 10 00 77 	sethi  %hi(0x4001dc00), %g1                    
40004860:	82 10 63 54 	or  %g1, 0x354, %g1	! 4001df54 <rtems_filesystem_default_pathconf>
40004864:	c2 27 60 2c 	st  %g1, [ %i5 + 0x2c ]                        
                                                                      
    mt_fs_root->location.mt_entry = mt_entry;                         
    mt_fs_root->reference_count = 1;                                  
40004868:	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 );
4000486c:	90 07 60 14 	add  %i5, 0x14, %o0                            
40004870:	92 10 00 16 	mov  %l6, %o1                                  
40004874:	94 10 20 01 	mov  1, %o2                                    
40004878:	96 10 20 24 	mov  0x24, %o3                                 
4000487c:	c2 27 60 58 	st  %g1, [ %i5 + 0x58 ]                        
      mt_entry->dev = str;                                            
      str += source_size;                                             
    }                                                                 
                                                                      
    memcpy( str, target, target_size );                               
    mt_entry->target = str;                                           
40004880:	f4 27 60 30 	st  %i2, [ %i5 + 0x30 ]                        
    str += target_size;                                               
                                                                      
    mt_entry->mounted = true;                                         
    mt_entry->mt_fs_root = mt_fs_root;                                
40004884:	ec 27 60 24 	st  %l6, [ %i5 + 0x24 ]                        
40004888:	40 00 12 31 	call  4000914c <_Chain_Initialize>             
4000488c:	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 );                       
40004890:	90 10 00 1d 	mov  %i5, %o0                                  
        filesystemtype,                                               
        &target_length                                                
      );                                                              
                                                                      
      if ( mt_entry != NULL ) {                                       
        mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE; 
40004894:	b6 0e e0 01 	and  %i3, 1, %i3                               
                                                                      
        rv = (*fsmount_me_h)( mt_entry, data );                       
40004898:	92 10 00 1c 	mov  %i4, %o1                                  
4000489c:	9f c4 80 00 	call  %l2                                      
400048a0:	f6 2f 60 29 	stb  %i3, [ %i5 + 0x29 ]                       
        if ( rv == 0 ) {                                              
400048a4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400048a8:	12 80 00 29 	bne  4000494c <mount+0x1c4>                    
400048ac:	80 a6 60 00 	cmp  %i1, 0                                    
          if ( target != NULL ) {                                     
400048b0:	02 80 00 58 	be  40004a10 <mount+0x288>                     
400048b4:	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 =                      
400048b8:	94 10 20 1f 	mov  0x1f, %o2                                 
400048bc:	40 00 02 e8 	call  4000545c <rtems_filesystem_eval_path_start>
400048c0:	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;
400048c4:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
                                                                      
  return (*mt_entry->ops->are_nodes_equal_h)(                         
400048c8:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
400048cc:	d2 00 60 24 	ld  [ %g1 + 0x24 ], %o1                        
400048d0:	c2 00 a0 10 	ld  [ %g2 + 0x10 ], %g1                        
400048d4:	9f c0 40 00 	call  %g1                                      
400048d8:	01 00 00 00 	nop                                            
    rtems_filesystem_eval_path_start( &ctx, target, eval_flags );     
                                                                      
  if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {  
400048dc:	80 8a 20 ff 	btst  0xff, %o0                                
400048e0:	12 80 00 70 	bne  40004aa0 <mount+0x318>                    
400048e4:	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(                          
400048e8:	40 00 03 d6 	call  40005840 <rtems_filesystem_location_copy_and_detach>
400048ec:	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 );
400048f0:	40 00 04 63 	call  40005a7c <rtems_filesystem_location_transform_to_global>
400048f4:	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 );
400048f8:	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 );
400048fc:	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 );
40004900:	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;                          
40004904:	d0 27 60 20 	st  %o0, [ %i5 + 0x20 ]                        
    rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40004908:	c2 00 60 30 	ld  [ %g1 + 0x30 ], %g1                        
4000490c:	9f c0 40 00 	call  %g1                                      
40004910:	90 10 00 1d 	mov  %i5, %o0                                  
    if ( rv == 0 ) {                                                  
40004914:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40004918:	22 80 00 11 	be,a   4000495c <mount+0x1d4>                  
4000491c:	39 10 00 80 	sethi  %hi(0x40020000), %i4                    
        &rtems_filesystem_mount_table,                                
        &mt_entry->mt_node                                            
      );                                                              
      rtems_filesystem_mt_unlock();                                   
    } else {                                                          
      rtems_filesystem_global_location_release( mt_point_node );      
40004920:	40 00 03 fd 	call  40005914 <rtems_filesystem_global_location_release>
40004924:	90 10 00 1c 	mov  %i4, %o0                                  
  } else {                                                            
    rtems_filesystem_eval_path_error( &ctx, EBUSY );                  
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40004928:	40 00 03 0d 	call  4000555c <rtems_filesystem_eval_path_cleanup>
4000492c:	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 ) {                                            
40004930:	80 a6 20 00 	cmp  %i0, 0                                    
40004934:	02 80 00 59 	be  40004a98 <mount+0x310>                     
40004938:	01 00 00 00 	nop                                            
            (*mt_entry->ops->fsunmount_me_h)( mt_entry );             
4000493c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
40004940:	c2 00 60 3c 	ld  [ %g1 + 0x3c ], %g1                        
40004944:	9f c0 40 00 	call  %g1                                      
40004948:	90 10 00 1d 	mov  %i5, %o0                                  
          }                                                           
        }                                                             
                                                                      
        if ( rv != 0 ) {                                              
          free( mt_entry );                                           
4000494c:	7f ff fe 2f 	call  40004208 <free>                          
40004950:	90 10 00 1d 	mov  %i5, %o0                                  
    errno = EINVAL;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40004954:	81 c7 e0 08 	ret                                            
40004958:	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 );
4000495c:	d0 07 21 2c 	ld  [ %i4 + 0x12c ], %o0                       
40004960:	92 10 20 00 	clr  %o1                                       
40004964:	40 00 0f 0a 	call  4000858c <rtems_semaphore_obtain>        
40004968:	94 10 20 00 	clr  %o2                                       
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
4000496c:	d0 07 21 2c 	ld  [ %i4 + 0x12c ], %o0                       
  Chain_Control *the_chain,                                           
  Chain_Node    *the_node                                             
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
40004970:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
40004974:	82 10 61 d0 	or  %g1, 0x1d0, %g1	! 4001f5d0 <rtems_filesystem_mount_table>
40004978:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
                                                                      
  the_node->next = tail;                                              
4000497c:	86 00 60 04 	add  %g1, 4, %g3                               
40004980:	c6 27 40 00 	st  %g3, [ %i5 ]                               
  tail->previous = the_node;                                          
40004984:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
  old_last->next = the_node;                                          
40004988:	fa 20 80 00 	st  %i5, [ %g2 ]                               
4000498c:	40 00 0f 4f 	call  400086c8 <rtems_semaphore_release>       
40004990:	c4 27 60 04 	st  %g2, [ %i5 + 4 ]                           
40004994:	30 bf ff e5 	b,a   40004928 <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;          
40004998:	40 00 35 4f 	call  40011ed4 <strlen>                        
4000499c:	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 : "/"; 
400049a0:	2b 10 00 77 	sethi  %hi(0x4001dc00), %l5                    
400049a4:	a6 10 20 02 	mov  2, %l3                                    
400049a8:	aa 15 63 50 	or  %l5, 0x350, %l5                            
  size_t filesystemtype_size = strlen( filesystemtype ) + 1;          
400049ac:	ba 10 00 08 	mov  %o0, %i5                                  
  size_t source_size = source_or_null != NULL ?                       
    strlen( source_or_null ) + 1 : 0;                                 
400049b0:	80 a6 20 00 	cmp  %i0, 0                                    
400049b4:	12 bf ff 8a 	bne  400047dc <mount+0x54>                     <== NEVER TAKEN
400049b8:	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                 
400049bc:	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;                                 
400049c0:	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                 
400049c4:	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 ); 
400049c8:	90 10 20 01 	mov  1, %o0                                    
400049cc:	7f ff fd 60 	call  40003f4c <calloc>                        
400049d0:	92 02 40 11 	add  %o1, %l1, %o1                             
                                                                      
  if ( mt_entry != NULL ) {                                           
400049d4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400049d8:	12 bf ff 8c 	bne  40004808 <mount+0x80>                     <== ALWAYS TAKEN
400049dc:	a0 07 60 64 	add  %i5, 0x64, %l0                            
                                                                      
        if ( rv != 0 ) {                                              
          free( mt_entry );                                           
        }                                                             
      } else {                                                        
        errno = ENOMEM;                                               
400049e0:	40 00 2f d8 	call  40010940 <__errno>                       <== NOT EXECUTED
400049e4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400049e8:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
400049ec:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400049f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400049f4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    } else {                                                          
      errno = EINVAL;                                                 
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
400049f8:	40 00 2f d2 	call  40010940 <__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                                        
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
40004a10:	39 10 00 80 	sethi  %hi(0x40020000), %i4                    
40004a14:	d0 07 21 2c 	ld  [ %i4 + 0x12c ], %o0	! 4002012c <rtems_libio_semaphore>
40004a18:	92 10 20 00 	clr  %o1                                       
40004a1c:	40 00 0e dc 	call  4000858c <rtems_semaphore_obtain>        
40004a20:	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;                    
40004a24:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  rtems_filesystem_mt_lock();                                         
  if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {      
40004a28:	c4 00 61 d0 	ld  [ %g1 + 0x1d0 ], %g2	! 4001f5d0 <rtems_filesystem_mount_table>
40004a2c:	82 10 61 d0 	or  %g1, 0x1d0, %g1                            
40004a30:	86 00 60 04 	add  %g1, 4, %g3                               
40004a34:	80 a0 80 03 	cmp  %g2, %g3                                  
40004a38:	12 80 00 1f 	bne  40004ab4 <mount+0x32c>                    <== NEVER TAKEN
40004a3c:	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;                              
40004a40:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
40004a44:	d0 07 21 2c 	ld  [ %i4 + 0x12c ], %o0                       
                                                                      
  the_node->next = tail;                                              
40004a48:	c4 27 40 00 	st  %g2, [ %i5 ]                               
  tail->previous = the_node;                                          
40004a4c:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
  old_last->next = the_node;                                          
40004a50:	fa 20 c0 00 	st  %i5, [ %g3 ]                               
40004a54:	40 00 0f 1d 	call  400086c8 <rtems_semaphore_release>       
40004a58:	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 );
40004a5c:	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 =                 
40004a60:	40 00 03 cd 	call  40005994 <rtems_filesystem_global_location_obtain>
40004a64:	90 10 00 1d 	mov  %i5, %o0                                  
40004a68:	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 =              
40004a6c:	40 00 03 ca 	call  40005994 <rtems_filesystem_global_location_obtain>
40004a70:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
                                                                      
    rtems_filesystem_global_location_assign(                          
40004a74:	39 10 00 7d 	sethi  %hi(0x4001f400), %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 =              
40004a78:	ba 10 00 08 	mov  %o0, %i5                                  
      rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
                                                                      
    rtems_filesystem_global_location_assign(                          
40004a7c:	d0 07 21 f0 	ld  [ %i4 + 0x1f0 ], %o0                       
40004a80:	92 10 00 1b 	mov  %i3, %o1                                  
40004a84:	40 00 03 ba 	call  4000596c <rtems_filesystem_global_location_assign>
40004a88:	90 02 20 04 	add  %o0, 4, %o0                               
      &rtems_filesystem_root,                                         
      new_fs_root                                                     
    );                                                                
    rtems_filesystem_global_location_assign(                          
40004a8c:	d0 07 21 f0 	ld  [ %i4 + 0x1f0 ], %o0                       
40004a90:	40 00 03 b7 	call  4000596c <rtems_filesystem_global_location_assign>
40004a94:	92 10 00 1d 	mov  %i5, %o1                                  
40004a98:	81 c7 e0 08 	ret                                            
40004a9c:	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 );                  
40004aa0:	90 07 bf c8 	add  %fp, -56, %o0                             
40004aa4:	92 10 20 10 	mov  0x10, %o1                                 
40004aa8:	40 00 01 b1 	call  4000516c <rtems_filesystem_eval_path_error>
40004aac:	b0 10 3f ff 	mov  -1, %i0                                   
40004ab0:	30 bf ff 9e 	b,a   40004928 <mount+0x1a0>                   
    rtems_chain_append_unprotected(                                   
      &rtems_filesystem_mount_table,                                  
      &mt_entry->mt_node                                              
    );                                                                
  } else {                                                            
    errno = EINVAL;                                                   
40004ab4:	40 00 2f a3 	call  40010940 <__errno>                       <== NOT EXECUTED
40004ab8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40004abc:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40004ac0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40004ac4:	40 00 0f 01 	call  400086c8 <rtems_semaphore_release>       <== NOT EXECUTED
40004ac8:	d0 07 21 2c 	ld  [ %i4 + 0x12c ], %o0                       <== NOT EXECUTED
          } else {                                                    
            rv = register_root_file_system( mt_entry );               
          }                                                           
                                                                      
          if ( rv != 0 ) {                                            
            (*mt_entry->ops->fsunmount_me_h)( mt_entry );             
40004acc:	10 bf ff 9d 	b  40004940 <mount+0x1b8>                      <== NOT EXECUTED
40004ad0:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
                                                                      

400099b4 <mount_and_make_target_path>: const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) {
400099b4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = -1;                                                        
                                                                      
  if (target != NULL) {                                               
400099b8:	90 96 60 00 	orcc  %i1, 0, %o0                              
400099bc:	02 80 00 0b 	be  400099e8 <mount_and_make_target_path+0x34> 
400099c0:	01 00 00 00 	nop                                            
    rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);            
400099c4:	40 00 02 ea 	call  4000a56c <rtems_mkdir>                   
400099c8:	92 10 21 ff 	mov  0x1ff, %o1	! 1ff <PROM_START+0x1ff>       
    if (rv == 0) {                                                    
400099cc:	82 92 20 00 	orcc  %o0, 0, %g1                              
400099d0:	02 80 00 04 	be  400099e0 <mount_and_make_target_path+0x2c> <== ALWAYS TAKEN
400099d4:	01 00 00 00 	nop                                            
  } else {                                                            
    errno = EINVAL;                                                   
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400099d8:	81 c7 e0 08 	ret                                            
400099dc:	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(                                                     
400099e0:	40 00 00 08 	call  40009a00 <mount>                         
400099e4:	81 e8 00 00 	restore                                        
        options,                                                      
        data                                                          
      );                                                              
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
400099e8:	40 00 68 54 	call  40023b38 <__errno>                       
400099ec:	01 00 00 00 	nop                                            
400099f0:	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;                                                        
400099f4:	82 10 3f ff 	mov  -1, %g1                                   
        options,                                                      
        data                                                          
      );                                                              
    }                                                                 
  } else {                                                            
    errno = EINVAL;                                                   
400099f8:	10 bf ff f8 	b  400099d8 <mount_and_make_target_path+0x24>  
400099fc:	c4 22 00 00 	st  %g2, [ %o0 ]                               
                                                                      

40008778 <mq_open>: int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) {
40008778:	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;                  
4000877c:	03 10 00 93 	sethi  %hi(0x40024c00), %g1                    
40008780:	c4 00 60 b0 	ld  [ %g1 + 0xb0 ], %g2	! 40024cb0 <_Thread_Dispatch_disable_level>
  size_t                          name_len;                           
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
40008784:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
                                                                      
    ++level;                                                          
40008788:	84 00 a0 01 	inc  %g2                                       
4000878c:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
40008790:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40008794:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
    _Thread_Dispatch_disable_level = level;                           
40008798:	c4 20 60 b0 	st  %g2, [ %g1 + 0xb0 ]                        
  Objects_Locations               location;                           
  size_t                          name_len;                           
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
4000879c:	a2 8e 62 00 	andcc  %i1, 0x200, %l1                         
400087a0:	12 80 00 36 	bne  40008878 <mq_open+0x100>                  
400087a4:	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 *)                           
400087a8:	39 10 00 94 	sethi  %hi(0x40025000), %i4                    
400087ac:	40 00 0c 21 	call  4000b830 <_Objects_Allocate>             
400087b0:	90 17 21 80 	or  %i4, 0x180, %o0	! 40025180 <_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 ) {                                                 
400087b4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400087b8:	02 80 00 39 	be  4000889c <mq_open+0x124>                   <== NEVER TAKEN
400087bc:	01 00 00 00 	nop                                            
    _Thread_Enable_dispatch();                                        
    rtems_set_errno_and_return_minus_one( ENFILE );                   
  }                                                                   
  the_mq_fd->oflag = oflag;                                           
400087c0:	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 );
400087c4:	35 10 00 93 	sethi  %hi(0x40024c00), %i2                    
400087c8:	92 10 00 18 	mov  %i0, %o1                                  
400087cc:	90 16 a3 f4 	or  %i2, 0x3f4, %o0                            
400087d0:	94 07 bf f0 	add  %fp, -16, %o2                             
400087d4:	40 00 01 42 	call  40008cdc <_POSIX_Name_to_id>             
400087d8:	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 ) {                                                     
400087dc:	b6 92 20 00 	orcc  %o0, 0, %i3                              
400087e0:	22 80 00 0f 	be,a   4000881c <mq_open+0xa4>                 
400087e4:	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) ) ) {               
400087e8:	80 a6 e0 02 	cmp  %i3, 2                                    
400087ec:	02 80 00 3f 	be  400088e8 <mq_open+0x170>                   
400087f0:	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 );
400087f4:	90 17 21 80 	or  %i4, 0x180, %o0                            
400087f8:	40 00 0d 06 	call  4000bc10 <_Objects_Free>                 
400087fc:	92 10 00 1d 	mov  %i5, %o1                                  
      _POSIX_Message_queue_Free_fd( the_mq_fd );                      
      _Thread_Enable_dispatch();                                      
40008800:	40 00 11 58 	call  4000cd60 <_Thread_Enable_dispatch>       
40008804:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( status, mqd_t );     
40008808:	40 00 28 15 	call  4001285c <__errno>                       
4000880c:	01 00 00 00 	nop                                            
40008810:	f6 22 00 00 	st  %i3, [ %o0 ]                               
40008814:	81 c7 e0 08 	ret                                            
40008818:	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) ) {       
4000881c:	80 a6 6a 00 	cmp  %i1, 0xa00                                
40008820:	02 80 00 27 	be  400088bc <mq_open+0x144>                   
40008824:	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 *)                              
40008828:	94 07 bf f8 	add  %fp, -8, %o2                              
4000882c:	40 00 0d 5f 	call  4000bda8 <_Objects_Get>                  
40008830:	90 16 a3 f4 	or  %i2, 0x3f4, %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;                                          
40008834:	c4 02 20 18 	ld  [ %o0 + 0x18 ], %g2                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40008838:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
4000883c:	84 00 a0 01 	inc  %g2                                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40008840:	b8 17 21 80 	or  %i4, 0x180, %i4                            
40008844:	c4 22 20 18 	st  %g2, [ %o0 + 0x18 ]                        
40008848:	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 );        
4000884c:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         
    the_mq->open_count += 1;                                          
    the_mq_fd->Queue = the_mq;                                        
40008850:	d0 27 60 10 	st  %o0, [ %i5 + 0x10 ]                        
40008854:	83 28 60 02 	sll  %g1, 2, %g1                               
40008858:	fa 20 80 01 	st  %i5, [ %g2 + %g1 ]                         
    _Objects_Open_string(                                             
      &_POSIX_Message_queue_Information_fds,                          
      &the_mq_fd->Object,                                             
      NULL                                                            
    );                                                                
    _Thread_Enable_dispatch();                                        
4000885c:	40 00 11 41 	call  4000cd60 <_Thread_Enable_dispatch>       
40008860:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    _Thread_Enable_dispatch();                                        
40008864:	40 00 11 3f 	call  4000cd60 <_Thread_Enable_dispatch>       
40008868:	01 00 00 00 	nop                                            
    return (mqd_t)the_mq_fd->Object.id;                               
4000886c:	f0 07 60 08 	ld  [ %i5 + 8 ], %i0                           
40008870:	81 c7 e0 08 	ret                                            
40008874:	81 e8 00 00 	restore                                        
  size_t                          name_len;                           
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
40008878:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            
    mode = va_arg( arg, mode_t );                                     
    attr = va_arg( arg, struct mq_attr * );                           
4000887c:	e0 07 a0 50 	ld  [ %fp + 0x50 ], %l0                        
  size_t                          name_len;                           
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
40008880:	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 *)                           
40008884:	39 10 00 94 	sethi  %hi(0x40025000), %i4                    
40008888:	40 00 0b ea 	call  4000b830 <_Objects_Allocate>             
4000888c:	90 17 21 80 	or  %i4, 0x180, %o0	! 40025180 <_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 ) {                                                 
40008890:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40008894:	32 bf ff cc 	bne,a   400087c4 <mq_open+0x4c>                
40008898:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
    _Thread_Enable_dispatch();                                        
4000889c:	40 00 11 31 	call  4000cd60 <_Thread_Enable_dispatch>       
400088a0:	b0 10 3f ff 	mov  -1, %i0                                   
    rtems_set_errno_and_return_minus_one( ENFILE );                   
400088a4:	40 00 27 ee 	call  4001285c <__errno>                       
400088a8:	01 00 00 00 	nop                                            
400088ac:	82 10 20 17 	mov  0x17, %g1	! 17 <PROM_START+0x17>          
400088b0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400088b4:	81 c7 e0 08 	ret                                            
400088b8:	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 );
400088bc:	90 17 21 80 	or  %i4, 0x180, %o0                            
400088c0:	40 00 0c d4 	call  4000bc10 <_Objects_Free>                 
400088c4:	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();                                      
400088c8:	40 00 11 26 	call  4000cd60 <_Thread_Enable_dispatch>       
400088cc:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );     
400088d0:	40 00 27 e3 	call  4001285c <__errno>                       
400088d4:	01 00 00 00 	nop                                            
400088d8:	82 10 20 11 	mov  0x11, %g1	! 11 <PROM_START+0x11>          
400088dc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400088e0:	81 c7 e0 08 	ret                                            
400088e4:	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) ) ) {               
400088e8:	02 bf ff c4 	be  400087f8 <mq_open+0x80>                    
400088ec:	90 17 21 80 	or  %i4, 0x180, %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(                       
400088f0:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
400088f4:	90 10 00 18 	mov  %i0, %o0                                  
400088f8:	94 10 20 01 	mov  1, %o2                                    
400088fc:	96 10 00 10 	mov  %l0, %o3                                  
40008900:	40 00 1b d1 	call  4000f844 <_POSIX_Message_queue_Create_support>
40008904:	98 07 bf f4 	add  %fp, -12, %o4                             
  );                                                                  
                                                                      
  /*                                                                  
   * errno was set by Create_support, so don't set it again.          
   */                                                                 
  if ( status == -1 ) {                                               
40008908:	80 a2 3f ff 	cmp  %o0, -1                                   
4000890c:	02 80 00 0d 	be  40008940 <mq_open+0x1c8>                   
40008910:	c6 07 bf f4 	ld  [ %fp + -12 ], %g3                         
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  const char          *name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40008914:	c2 17 60 0a 	lduh  [ %i5 + 0xa ], %g1                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40008918:	b8 17 21 80 	or  %i4, 0x180, %i4                            
4000891c:	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;                                          
40008920:	c6 27 60 10 	st  %g3, [ %i5 + 0x10 ]                        
40008924:	83 28 60 02 	sll  %g1, 2, %g1                               
40008928:	fa 20 80 01 	st  %i5, [ %g2 + %g1 ]                         
    &_POSIX_Message_queue_Information_fds,                            
    &the_mq_fd->Object,                                               
    NULL                                                              
  );                                                                  
                                                                      
  _Thread_Enable_dispatch();                                          
4000892c:	40 00 11 0d 	call  4000cd60 <_Thread_Enable_dispatch>       
40008930:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
                                                                      
  return (mqd_t) the_mq_fd->Object.id;                                
40008934:	f0 07 60 08 	ld  [ %i5 + 8 ], %i0                           
}                                                                     
40008938:	81 c7 e0 08 	ret                                            
4000893c:	81 e8 00 00 	restore                                        
40008940:	90 17 21 80 	or  %i4, 0x180, %o0                            
40008944:	92 10 00 1d 	mov  %i5, %o1                                  
40008948:	40 00 0c b2 	call  4000bc10 <_Objects_Free>                 
4000894c:	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();                                        
40008950:	40 00 11 04 	call  4000cd60 <_Thread_Enable_dispatch>       
40008954:	01 00 00 00 	nop                                            
40008958:	81 c7 e0 08 	ret                                            
4000895c:	81 e8 00 00 	restore                                        
                                                                      

40019258 <msdos_creat_node>: msdos_node_type_t type, const char *name, int name_len, mode_t mode, const fat_file_fd_t *link_fd) {
40019258:	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;        
4001925c:	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);         
40019260:	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;        
40019264:	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;                                  
40019268:	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;                           
4001926c:	82 10 3f ff 	mov  -1, %g1                                   
    time_t            time_ret = 0;                                   
    uint16_t          time_val = 0;                                   
40019270:	c0 37 bf 68 	clrh  [ %fp + -152 ]                           
    uint16_t          date = 0;                                       
40019274:	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;                                             
40019278:	c0 27 bf 70 	clr  [ %fp + -144 ]                            
  dir_pos->sname.ofs = 0;                                             
4001927c:	c0 27 bf 74 	clr  [ %fp + -140 ]                            
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
40019280:	c2 27 bf 78 	st  %g1, [ %fp + -136 ]                        
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
40019284:	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);         
40019288:	c0 27 bf 80 	clr  [ %fp + -128 ]                            
4001928c:	c0 27 bf 84 	clr  [ %fp + -124 ]                            
40019290:	c0 27 20 08 	clr  [ %i4 + 8 ]                               
40019294:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             
40019298:	c0 27 20 10 	clr  [ %i4 + 0x10 ]                            
4001929c:	c0 27 20 14 	clr  [ %i4 + 0x14 ]                            
400192a0:	c0 27 20 18 	clr  [ %i4 + 0x18 ]                            
400192a4:	c0 27 20 1c 	clr  [ %i4 + 0x1c ]                            
    memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);     
400192a8:	c0 27 bf c0 	clr  [ %fp + -64 ]                             
400192ac:	c0 27 bf c4 	clr  [ %fp + -60 ]                             
400192b0:	c0 27 bf c8 	clr  [ %fp + -56 ]                             
400192b4:	c0 27 bf cc 	clr  [ %fp + -52 ]                             
400192b8:	c0 27 bf d0 	clr  [ %fp + -48 ]                             
400192bc:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
400192c0:	c0 27 bf d8 	clr  [ %fp + -40 ]                             
400192c4:	c0 27 bf dc 	clr  [ %fp + -36 ]                             
400192c8:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
400192cc:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
400192d0:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
400192d4:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
400192d8:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
400192dc:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
400192e0:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
400192e4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
    if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {                     
400192e8:	80 a6 e1 04 	cmp  %i3, 0x104                                
400192ec:	14 80 00 e3 	bg  40019678 <msdos_creat_node+0x420>          <== NEVER TAKEN
400192f0:	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,                  
400192f4:	90 10 00 1a 	mov  %i2, %o0                                  
400192f8:	92 10 00 1b 	mov  %i3, %o1                                  
400192fc:	94 10 00 1c 	mov  %i4, %o2                                  
40019300:	40 00 01 37 	call  400197dc <msdos_long_to_short>           
40019304:	96 10 20 0b 	mov  0xb, %o3                                  
                                     MSDOS_DIR_NAME(short_node),      
                                     MSDOS_NAME_MAX);                 
    if (name_type == MSDOS_NAME_INVALID) {                            
40019308:	a4 92 20 00 	orcc  %o0, 0, %l2                              
4001930c:	02 80 00 e0 	be  4001968c <msdos_creat_node+0x434>          <== NEVER TAKEN
40019310:	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;               
40019314:	c0 2f bf 8c 	clrb  [ %fp + -116 ]                           
                                                                      
    /* set up last write date and time */                             
    time_ret = time(NULL);                                            
40019318:	40 00 22 21 	call  40021b9c <time>                          
4001931c:	90 10 20 00 	clr  %o0                                       
    if ( time_ret == -1 )                                             
40019320:	80 a2 3f ff 	cmp  %o0, -1                                   
40019324:	02 80 00 df 	be  400196a0 <msdos_creat_node+0x448>          <== NEVER TAKEN
40019328:	92 07 bf 6a 	add  %fp, -150, %o1                            
        return -1;                                                    
                                                                      
    msdos_date_unix2dos(time_ret, &date, &time_val);                  
4001932c:	40 00 0c 87 	call  4001c548 <msdos_date_unix2dos>           
40019330:	94 07 bf 68 	add  %fp, -152, %o2                            
    *MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);              
40019334:	c8 17 bf 68 	lduh  [ %fp + -152 ], %g4                      
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40019338:	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);              
4001933c:	89 29 20 10 	sll  %g4, 0x10, %g4                            
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40019340:	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);              
40019344:	85 31 20 08 	srl  %g4, 8, %g2                               
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40019348:	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);              
4001934c:	89 31 20 18 	srl  %g4, 0x18, %g4                            
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40019350:	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);              
40019354:	84 10 80 04 	or  %g2, %g4, %g2                              
    *MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);                  
40019358:	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);              
4001935c:	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);            
40019360:	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);                  
40019364:	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);                
40019368:	c2 37 bf 98 	sth  %g1, [ %fp + -104 ]                       
    *MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);          
4001936c:	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) {                                    
40019370:	80 a6 60 00 	cmp  %i1, 0                                    
40019374:	02 80 00 12 	be  400193bc <msdos_creat_node+0x164>          
40019378:	c0 27 bf 9c 	clr  [ %fp + -100 ]                            
      *MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;            
    }                                                                 
    else if (type == MSDOS_HARD_LINK) {                               
4001937c:	80 a6 60 02 	cmp  %i1, 2                                    
40019380:	02 80 00 89 	be  400195a4 <msdos_creat_node+0x34c>          <== NEVER TAKEN
40019384:	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;            
40019388:	82 10 60 20 	or  %g1, 0x20, %g1                             
4001938c:	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,        
40019390:	f8 23 a0 5c 	st  %i4, [ %sp + 0x5c ]                        
40019394:	90 10 00 18 	mov  %i0, %o0                                  
40019398:	92 10 20 01 	mov  1, %o1                                    
4001939c:	94 10 00 1a 	mov  %i2, %o2                                  
400193a0:	96 10 00 1b 	mov  %i3, %o3                                  
400193a4:	98 10 00 12 	mov  %l2, %o4                                  
400193a8:	40 00 06 b8 	call  4001ae88 <msdos_get_name_node>           
400193ac:	9a 07 bf 70 	add  %fp, -144, %o5                            
400193b0:	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;                                                        
}                                                                     
400193b4:	81 c7 e0 08 	ret                                            
400193b8:	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;            
400193bc:	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,        
400193c0:	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;            
400193c4:	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,        
400193c8:	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;            
400193cc:	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,        
400193d0:	92 10 20 01 	mov  1, %o1                                    
400193d4:	94 10 00 1a 	mov  %i2, %o2                                  
400193d8:	96 10 00 1b 	mov  %i3, %o3                                  
400193dc:	98 10 00 12 	mov  %l2, %o4                                  
400193e0:	40 00 06 aa 	call  4001ae88 <msdos_get_name_node>           
400193e4:	9a 07 bf 70 	add  %fp, -144, %o5                            
                             name_type, &dir_pos, short_node);        
    if ( rc != RC_OK )                                                
400193e8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400193ec:	12 bf ff f2 	bne  400193b4 <msdos_creat_node+0x15c>         <== NEVER TAKEN
400193f0:	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);         
400193f4:	92 07 bf 70 	add  %fp, -144, %o1                            
400193f8:	7f ff e8 ac 	call  400136a8 <fat_file_open>                 
400193fc:	94 07 bf 6c 	add  %fp, -148, %o2                            
        if (rc != RC_OK)                                              
40019400:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40019404:	32 80 00 62 	bne,a   4001958c <msdos_creat_node+0x334>      <== NEVER TAKEN
40019408:	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;                                    
4001940c:	f2 07 bf 6c 	ld  [ %fp + -148 ], %i1                        
        fat_fd->fat_file_type = FAT_DIRECTORY;                        
        fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                    
40019410:	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;                                    
40019414:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
        fat_fd->fat_file_type = FAT_DIRECTORY;                        
        fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                    
40019418:	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;                        
4001941c:	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,
40019420:	03 10 00 b8 	sethi  %hi(0x4002e000), %g1                    
                                                                      
        /*                                                            
         * dot and dotdot entries are identical to new node except the
         * names                                                      
         */                                                           
        memcpy(DOT_NODE_P(dot_dotdot), short_node,                    
40019424:	d8 1f bf 80 	ldd  [ %fp + -128 ], %o4                       
40019428:	c4 1f bf 98 	ldd  [ %fp + -104 ], %g2                       
4001942c:	f4 1f bf 88 	ldd  [ %fp + -120 ], %i2                       
40019430:	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,
40019434:	d2 00 63 ac 	ld  [ %g1 + 0x3ac ], %o1                       
40019438:	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,                    
4001943c:	d8 3f bf c0 	std  %o4, [ %fp + -64 ]                        
40019440:	c4 3f bf d8 	std  %g2, [ %fp + -40 ]                        
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,                 
40019444:	d8 3f bf e0 	std  %o4, [ %fp + -32 ]                        
40019448:	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,                    
4001944c:	f4 3f bf c8 	std  %i2, [ %fp + -56 ]                        
40019450:	f8 3f bf d0 	std  %i4, [ %fp + -48 ]                        
               MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);                    
        memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,                 
40019454:	f4 3f bf e8 	std  %i2, [ %fp + -24 ]                        
40019458:	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,
4001945c:	40 00 12 f2 	call  4001e024 <memcpy>                        
40019460:	90 07 bf c0 	add  %fp, -64, %o0                             
               MSDOS_NAME_MAX);                                       
        memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
40019464:	03 10 00 b8 	sethi  %hi(0x4002e000), %g1                    
40019468:	d2 00 63 a8 	ld  [ %g1 + 0x3a8 ], %o1	! 4002e3a8 <MSDOS_DOTDOT_NAME>
4001946c:	90 07 bf e0 	add  %fp, -32, %o0                             
40019470:	40 00 12 ed 	call  4001e024 <memcpy>                        
40019474:	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)) &&                    
40019478:	c2 04 60 20 	ld  [ %l1 + 0x20 ], %g1                        
4001947c:	80 a0 60 01 	cmp  %g1, 1                                    
40019480:	22 80 00 73 	be,a   4001964c <msdos_creat_node+0x3f4>       
40019484:	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));
40019488:	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;                                                        
}                                                                     
4001948c:	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));
40019490:	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;                                                        
}                                                                     
40019494:	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)) = 
40019498:	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;                                                        
}                                                                     
4001949c:	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)) = 
400194a0:	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;                                                        
}                                                                     
400194a4:	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));
400194a8:	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));
400194ac:	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)) = 
400194b0:	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)) =  
400194b4:	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)) = 
400194b8:	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)) =  
400194bc:	84 10 c0 02 	or  %g3, %g2, %g2                              
400194c0:	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,                
400194c4:	90 10 00 10 	mov  %l0, %o0                                  
400194c8:	92 10 00 19 	mov  %i1, %o1                                  
400194cc:	94 10 20 00 	clr  %o2                                       
400194d0:	96 10 20 40 	mov  0x40, %o3                                 
400194d4:	7f ff ea e7 	call  40014070 <fat_file_write>                
400194d8:	98 07 bf c0 	add  %fp, -64, %o4                             
                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,   
                             (uint8_t *)dot_dotdot);                  
        if (ret < 0)                                                  
400194dc:	80 a2 20 00 	cmp  %o0, 0                                    
400194e0:	06 80 00 26 	bl  40019578 <msdos_creat_node+0x320>          <== NEVER TAKEN
400194e4:	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;                
400194e8:	c4 14 20 06 	lduh  [ %l0 + 6 ], %g2                         
400194ec:	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));    
400194f0:	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;                
400194f4:	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)) =        
400194f8:	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));
400194fc:	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;                
40019500:	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)) =         
40019504:	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)) =        
40019508:	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;                                                        
}                                                                     
4001950c:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
40019510:	84 10 a3 ff 	or  %g2, 0x3ff, %g2	! ffff <PROM_START+0xffff> 
40019514:	82 08 40 02 	and  %g1, %g2, %g1                             
40019518:	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));    
4001951c:	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));
40019520:	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)) =        
40019524:	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)) =         
40019528:	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,                
4001952c:	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)) =        
40019530:	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)) =         
40019534:	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,                
40019538:	94 10 20 00 	clr  %o2                                       
4001953c:	96 10 20 20 	mov  0x20, %o3                                 
40019540:	7f ff ea cc 	call  40014070 <fat_file_write>                
40019544:	98 07 bf c0 	add  %fp, -64, %o4                             
                             MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,       
                             (uint8_t *)DOT_NODE_P(dot_dotdot));      
        if (ret < 0)                                                  
40019548:	80 a2 20 00 	cmp  %o0, 0                                    
4001954c:	06 80 00 0c 	bl  4001957c <msdos_creat_node+0x324>          <== NEVER TAKEN
40019550:	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);
40019554:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
40019558:	40 00 01 74 	call  40019b28 <msdos_set_first_cluster_num>   
4001955c:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        
        if (rc != RC_OK)                                              
40019560:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40019564:	12 80 00 07 	bne  40019580 <msdos_creat_node+0x328>         <== NEVER TAKEN
40019568:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        
            goto error;                                               
                                                                      
        fat_file_close(&fs_info->fat, fat_fd);                        
4001956c:	7f ff e9 c9 	call  40013c90 <fat_file_close>                
40019570:	90 10 00 10 	mov  %l0, %o0                                  
40019574:	30 bf ff 90 	b,a   400193b4 <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;                                                  
40019578:	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);                            
4001957c:	d2 07 bf 6c 	ld  [ %fp + -148 ], %o1                        <== NOT EXECUTED
40019580:	7f ff e9 c4 	call  40013c90 <fat_file_close>                <== NOT EXECUTED
40019584:	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);
40019588:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        <== NOT EXECUTED
4001958c:	92 07 bf 70 	add  %fp, -144, %o1                            <== NOT EXECUTED
40019590:	94 10 20 e5 	mov  0xe5, %o2                                 <== NOT EXECUTED
40019594:	40 00 01 c9 	call  40019cb8 <msdos_set_first_char4file_name><== NOT EXECUTED
40019598:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
    return rc;                                                        
}                                                                     
4001959c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400195a0:	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,              
400195a4:	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)) )
400195a8:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400195ac:	32 80 00 07 	bne,a   400195c8 <msdos_creat_node+0x370>      <== NOT EXECUTED
400195b0:	c6 0c 20 05 	ldub  [ %l0 + 5 ], %g3                         <== NOT EXECUTED
400195b4:	c4 0c 20 0e 	ldub  [ %l0 + 0xe ], %g2                       <== NOT EXECUTED
400195b8:	80 88 a0 03 	btst  3, %g2                                   <== NOT EXECUTED
400195bc:	32 80 00 07 	bne,a   400195d8 <msdos_creat_node+0x380>      <== NOT EXECUTED
400195c0:	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) +        
400195c4:	c6 0c 20 05 	ldub  [ %l0 + 5 ], %g3                         <== NOT EXECUTED
400195c8:	c4 04 20 34 	ld  [ %l0 + 0x34 ], %g2                        <== NOT EXECUTED
400195cc:	92 00 7f fe 	add  %g1, -2, %o1                              <== NOT EXECUTED
400195d0:	93 2a 40 03 	sll  %o1, %g3, %o1                             <== NOT EXECUTED
400195d4:	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);
400195d8:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        <== NOT EXECUTED
400195dc:	c4 0c 20 02 	ldub  [ %l0 + 2 ], %g2                         <== NOT EXECUTED
      byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
400195e0:	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);
400195e4:	85 30 40 02 	srl  %g1, %g2, %g2                             <== NOT EXECUTED
      byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
400195e8:	94 02 bf ff 	add  %o2, -1, %o2                              <== NOT EXECUTED
                                                                      
      ret = _fat_block_read(&fs_info->fat,                            
400195ec:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
400195f0:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
400195f4:	94 0a 80 01 	and  %o2, %g1, %o2                             <== NOT EXECUTED
400195f8:	96 10 20 20 	mov  0x20, %o3                                 <== NOT EXECUTED
400195fc:	7f ff ec 37 	call  400146d8 <_fat_block_read>               <== NOT EXECUTED
40019600:	98 07 bf a0 	add  %fp, -96, %o4                             <== NOT EXECUTED
                            sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
                            link_node);                               
      if (ret < 0) {                                                  
40019604:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40019608:	06 80 00 26 	bl  400196a0 <msdos_creat_node+0x448>          <== NOT EXECUTED
4001960c:	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);
40019610:	c2 0f bf ab 	ldub  [ %fp + -85 ], %g1                       <== NOT EXECUTED
      *MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
40019614:	c4 2f bf 8d 	stb  %g2, [ %fp + -115 ]                       <== NOT EXECUTED
      *MSDOS_DIR_CRT_TIME(short_node)      =*MSDOS_DIR_CRT_TIME(link_node);
40019618:	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;              
4001961c:	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);
40019620:	c4 37 bf 8e 	sth  %g2, [ %fp + -114 ]                       <== NOT EXECUTED
      *MSDOS_DIR_CRT_DATE(short_node)      =*MSDOS_DIR_CRT_DATE(link_node);
40019624:	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;              
40019628:	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);
4001962c:	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);
40019630:	c4 07 bf bc 	ld  [ %fp + -68 ], %g2                         <== NOT EXECUTED
40019634:	c4 27 bf 9c 	st  %g2, [ %fp + -100 ]                        <== NOT EXECUTED
                                                                      
      *MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =                      
40019638:	c4 17 bf ba 	lduh  [ %fp + -70 ], %g2                       <== NOT EXECUTED
4001963c:	c4 37 bf 9a 	sth  %g2, [ %fp + -102 ]                       <== NOT EXECUTED
           *MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);                   
      *MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =                       
40019640:	c4 17 bf b4 	lduh  [ %fp + -76 ], %g2                       <== NOT EXECUTED
40019644:	10 bf ff 53 	b  40019390 <msdos_creat_node+0x138>           <== NOT EXECUTED
40019648:	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)) &&                    
4001964c:	80 a0 60 00 	cmp  %g1, 0                                    
40019650:	32 bf ff 8f 	bne,a   4001948c <msdos_creat_node+0x234>      <== NEVER TAKEN
40019654:	c2 04 60 1c 	ld  [ %l1 + 0x1c ], %g1                        <== NOT EXECUTED
            (fs_info->fat.vol.type & FAT_FAT32))                      
40019658:	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)) &&                    
4001965c:	82 08 60 04 	and  %g1, 4, %g1                               
40019660:	80 88 60 ff 	btst  0xff, %g1                                
40019664:	22 bf ff 8a 	be,a   4001948c <msdos_creat_node+0x234>       <== ALWAYS TAKEN
40019668:	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;
4001966c:	c0 37 bf fa 	clrh  [ %fp + -6 ]                             <== NOT EXECUTED
            *MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
40019670:	10 bf ff 95 	b  400194c4 <msdos_creat_node+0x26c>           <== NOT EXECUTED
40019674:	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);           
40019678:	40 00 0f c6 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001967c:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
40019680:	82 10 20 5b 	mov  0x5b, %g1                                 <== NOT EXECUTED
40019684:	10 bf ff 4c 	b  400193b4 <msdos_creat_node+0x15c>           <== NOT EXECUTED
40019688:	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);                 
4001968c:	40 00 0f c1 	call  4001d590 <__errno>                       <== NOT EXECUTED
40019690:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
40019694:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40019698:	10 bf ff 47 	b  400193b4 <msdos_creat_node+0x15c>           <== NOT EXECUTED
4001969c:	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;                                                    
400196a0:	10 bf ff 45 	b  400193b4 <msdos_creat_node+0x15c>           <== NOT EXECUTED
400196a4:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
                                                                      

4001c6c0 <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) {
4001c6c0:	09 10 00 bd 	sethi  %hi(0x4002f400), %g4                    
4001c6c4:	da 11 20 ea 	lduh  [ %g4 + 0xea ], %o5	! 4002f4ea <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  
4001c6c8:	86 0a 67 e0 	and  %o1, 0x7e0, %g3                           
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
4001c6cc:	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  
4001c6d0:	83 30 e0 04 	srl  %g3, 4, %g1                               
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
4001c6d4:	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  
4001c6d8:	86 20 c0 01 	sub  %g3, %g1, %g3                             
	    + ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;   
4001c6dc:	99 28 a0 03 	sll  %g2, 3, %o4                               
4001c6e0:	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)
4001c6e4:	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;   
4001c6e8:	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) {                                             
4001c6ec:	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;   
4001c6f0:	85 28 60 04 	sll  %g1, 4, %g2                               
4001c6f4:	82 20 80 01 	sub  %g2, %g1, %g1                             
4001c6f8:	82 00 40 03 	add  %g1, %g3, %g1                             
4001c6fc:	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) {                                             
4001c700:	02 80 00 3a 	be  4001c7e8 <msdos_date_dos2unix+0x128>       
4001c704:	93 2a 60 01 	sll  %o1, 1, %o1                               
		lastdosdate = dd;                                                   
4001c708:	d0 31 20 ea 	sth  %o0, [ %g4 + 0xea ]                       
		days = 0;                                                           
		year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;            
		for (y = 0; y < year; y++)                                          
4001c70c:	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;            
4001c710:	89 32 20 09 	srl  %o0, 9, %g4                               
		for (y = 0; y < year; y++)                                          
4001c714:	84 10 20 00 	clr  %g2                                       
4001c718:	88 89 20 7f 	andcc  %g4, 0x7f, %g4                          
4001c71c:	12 80 00 08 	bne  4001c73c <msdos_date_dos2unix+0x7c>       <== ALWAYS TAKEN
4001c720:	86 10 21 6e 	mov  0x16e, %g3                                
			days += y & 0x03 ? 365 : 366;                                      
		months = year & 0x03 ? regyear : leapyear;                          
4001c724:	10 80 00 2f 	b  4001c7e0 <msdos_date_dos2unix+0x120>        <== NOT EXECUTED
4001c728:	09 10 00 bb 	sethi  %hi(0x4002ec00), %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;                                      
4001c72c:	86 08 a0 03 	and  %g2, 3, %g3                               
4001c730:	80 a0 00 03 	cmp  %g0, %g3                                  
4001c734:	86 60 3f ff 	subx  %g0, -1, %g3                             
4001c738:	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++)                                          
4001c73c:	84 00 a0 01 	inc  %g2                                       
4001c740:	80 a0 80 04 	cmp  %g2, %g4                                  
4001c744:	12 bf ff fa 	bne  4001c72c <msdos_date_dos2unix+0x6c>       
4001c748:	82 00 40 03 	add  %g1, %g3, %g1                             
			days += y & 0x03 ? 365 : 366;                                      
		months = year & 0x03 ? regyear : leapyear;                          
4001c74c:	80 88 a0 03 	btst  3, %g2                                   
4001c750:	02 80 00 24 	be  4001c7e0 <msdos_date_dos2unix+0x120>       <== ALWAYS TAKEN
4001c754:	09 10 00 bb 	sethi  %hi(0x4002ec00), %g4                    
4001c758:	09 10 00 bb 	sethi  %hi(0x4002ec00), %g4                    <== NOT EXECUTED
4001c75c:	88 11 21 18 	or  %g4, 0x118, %g4	! 4002ed18 <regyear>       <== NOT EXECUTED
		/*                                                                  
		 * Prevent going from 0 to 0xffffffff in the following              
		 * loop.                                                            
		 */                                                                 
		month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;         
4001c760:	9a 0a 21 e0 	and  %o0, 0x1e0, %o5                           
4001c764:	9b 33 60 05 	srl  %o5, 5, %o5                               
		if (month == 0) {                                                   
4001c768:	80 a3 60 00 	cmp  %o5, 0                                    
4001c76c:	22 80 00 0d 	be,a   4001c7a0 <msdos_date_dos2unix+0xe0>     <== NEVER TAKEN
4001c770:	90 0a 20 1f 	and  %o0, 0x1f, %o0                            <== NOT EXECUTED
			month = 1;                                                         
		}                                                                   
		for (m = 0; m < month - 1; m++)                                     
4001c774:	80 a3 60 01 	cmp  %o5, 1                                    
4001c778:	02 80 00 09 	be  4001c79c <msdos_date_dos2unix+0xdc>        <== ALWAYS TAKEN
4001c77c:	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)                 
4001c780:	9a 03 7f ff 	add  %o5, -1, %o5                              <== NOT EXECUTED
4001c784:	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];                                                 
4001c788:	c6 11 00 02 	lduh  [ %g4 + %g2 ], %g3                       <== NOT EXECUTED
4001c78c:	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++)                                     
4001c790:	80 a0 80 0d 	cmp  %g2, %o5                                  <== NOT EXECUTED
4001c794:	12 bf ff fd 	bne  4001c788 <msdos_date_dos2unix+0xc8>       <== NOT EXECUTED
4001c798:	82 00 40 03 	add  %g1, %g3, %g1                             <== NOT EXECUTED
			days += months[m];                                                 
		days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;       
4001c79c:	90 0a 20 1f 	and  %o0, 0x1f, %o0                            
4001c7a0:	90 02 3f ff 	add  %o0, -1, %o0                              
4001c7a4:	82 02 00 01 	add  %o0, %g1, %g1                             
		lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;                  
4001c7a8:	85 28 60 07 	sll  %g1, 7, %g2                               
4001c7ac:	83 28 60 09 	sll  %g1, 9, %g1                               
4001c7b0:	82 20 40 02 	sub  %g1, %g2, %g1                             
4001c7b4:	85 28 60 04 	sll  %g1, 4, %g2                               
4001c7b8:	82 20 80 01 	sub  %g2, %g1, %g1                             
4001c7bc:	85 28 60 04 	sll  %g1, 4, %g2                               
4001c7c0:	82 20 80 01 	sub  %g2, %g1, %g1                             
4001c7c4:	05 04 b3 a9 	sethi  %hi(0x12cea400), %g2                    
4001c7c8:	84 10 a2 00 	or  %g2, 0x200, %g2	! 12cea600 <RAM_SIZE+0x128ea600>
4001c7cc:	90 00 40 02 	add  %g1, %g2, %o0                             
4001c7d0:	05 10 00 bd 	sethi  %hi(0x4002f400), %g2                    
4001c7d4:	d0 20 a0 ec 	st  %o0, [ %g2 + 0xec ]	! 4002f4ec <lastseconds>
	}                                                                    
	return seconds + lastseconds;                                        
}                                                                     
4001c7d8:	81 c3 e0 08 	retl                                           
4001c7dc:	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;                          
4001c7e0:	10 bf ff e0 	b  4001c760 <msdos_date_dos2unix+0xa0>         
4001c7e4:	88 11 21 30 	or  %g4, 0x130, %g4                            
4001c7e8:	03 10 00 bd 	sethi  %hi(0x4002f400), %g1                    
4001c7ec:	d0 00 60 ec 	ld  [ %g1 + 0xec ], %o0	! 4002f4ec <lastseconds>
			days += months[m];                                                 
		days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;       
		lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;                  
	}                                                                    
	return seconds + lastseconds;                                        
}                                                                     
4001c7f0:	81 c3 e0 08 	retl                                           
4001c7f4:	90 02 00 09 	add  %o0, %o1, %o0                             
                                                                      

4001c548 <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) {
4001c548:	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) {                                                 
4001c54c:	03 10 00 bd 	sethi  %hi(0x4002f400), %g1                    
4001c550:	c4 00 60 dc 	ld  [ %g1 + 0xdc ], %g2	! 4002f4dc <lasttime>  
4001c554:	80 a0 80 18 	cmp  %g2, %i0                                  
4001c558:	02 80 00 4d 	be  4001c68c <msdos_date_unix2dos+0x144>       
4001c55c:	92 10 20 3c 	mov  0x3c, %o1                                 
		lasttime = t;                                                       
4001c560:	f0 20 60 dc 	st  %i0, [ %g1 + 0xdc ]                        
		lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)            
		    + (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)                   
4001c564:	7f ff 98 44 	call  40002674 <.udiv>                         
4001c568:	90 10 00 18 	mov  %i0, %o0                                  
4001c56c:	40 00 38 63 	call  4002a6f8 <.urem>                         
4001c570:	92 10 20 3c 	mov  0x3c, %o1                                 
		    + (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);                  
4001c574:	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)            
4001c578:	bb 2a 20 05 	sll  %o0, 5, %i5                               
		    + (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)                   
		    + (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);                  
4001c57c:	7f ff 98 3e 	call  40002674 <.udiv>                         
4001c580:	90 10 00 18 	mov  %i0, %o0                                  
4001c584:	40 00 38 5d 	call  4002a6f8 <.urem>                         
4001c588:	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)            
4001c58c:	83 2a 20 0b 	sll  %o0, 0xb, %g1                             
4001c590:	92 10 20 3c 	mov  0x3c, %o1                                 
4001c594:	ba 07 40 01 	add  %i5, %g1, %i5                             
4001c598:	40 00 38 58 	call  4002a6f8 <.urem>                         
4001c59c:	90 10 00 18 	mov  %i0, %o0                                  
4001c5a0:	05 10 00 bd 	sethi  %hi(0x4002f400), %g2                    
4001c5a4:	91 32 20 01 	srl  %o0, 1, %o0                               
4001c5a8:	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);                                         
4001c5ac:	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)            
4001c5b0:	c2 30 a0 e0 	sth  %g1, [ %g2 + 0xe0 ]                       
4001c5b4:	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);                                         
4001c5b8:	90 10 00 18 	mov  %i0, %o0                                  
4001c5bc:	7f ff 98 2e 	call  40002674 <.udiv>                         
4001c5c0:	92 12 61 80 	or  %o1, 0x180, %o1                            
		if (days != lastday) {                                              
4001c5c4:	03 10 00 bd 	sethi  %hi(0x4002f400), %g1                    
4001c5c8:	c4 00 60 e4 	ld  [ %g1 + 0xe4 ], %g2	! 4002f4e4 <lastday>   
4001c5cc:	80 a2 00 02 	cmp  %o0, %g2                                  
4001c5d0:	22 80 00 37 	be,a   4001c6ac <msdos_date_unix2dos+0x164>    
4001c5d4:	03 10 00 bd 	sethi  %hi(0x4002f400), %g1                    
			lastday = days;                                                    
4001c5d8:	d0 20 60 e4 	st  %o0, [ %g1 + 0xe4 ]	! 4002f4e4 <lastday>   
			for (year = 1970;; year++) {                                       
4001c5dc:	10 80 00 03 	b  4001c5e8 <msdos_date_unix2dos+0xa0>         
4001c5e0:	82 10 27 b2 	mov  0x7b2, %g1                                
4001c5e4:	82 00 60 01 	inc  %g1                                       
				inc = year & 0x03 ? 365 : 366;                                    
4001c5e8:	86 08 60 03 	and  %g1, 3, %g3                               
4001c5ec:	80 a0 00 03 	cmp  %g0, %g3                                  
4001c5f0:	84 60 3f ff 	subx  %g0, -1, %g2                             
4001c5f4:	84 00 a1 6d 	add  %g2, 0x16d, %g2                           
				if (days < inc)                                                   
4001c5f8:	80 a2 00 02 	cmp  %o0, %g2                                  
4001c5fc:	3a bf ff fa 	bcc,a   4001c5e4 <msdos_date_unix2dos+0x9c>    
4001c600:	90 22 00 02 	sub  %o0, %g2, %o0                             
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
4001c604:	80 a0 e0 00 	cmp  %g3, 0                                    
4001c608:	02 80 00 1d 	be  4001c67c <msdos_date_unix2dos+0x134>       <== ALWAYS TAKEN
4001c60c:	09 10 00 bb 	sethi  %hi(0x4002ec00), %g4                    
4001c610:	09 10 00 bb 	sethi  %hi(0x4002ec00), %g4                    <== NOT EXECUTED
4001c614:	88 11 21 18 	or  %g4, 0x118, %g4	! 4002ed18 <regyear>       <== NOT EXECUTED
			for (month = 0; month < 12; month++) {                             
4001c618:	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,                    
4001c61c:	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])                                         
4001c620:	c6 11 00 03 	lduh  [ %g4 + %g3 ], %g3                       
4001c624:	80 a0 c0 08 	cmp  %g3, %o0                                  
4001c628:	18 80 00 17 	bgu  4001c684 <msdos_date_unix2dos+0x13c>      <== ALWAYS TAKEN
4001c62c:	84 00 a0 01 	inc  %g2                                       
				if (days < inc)                                                   
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
			for (month = 0; month < 12; month++) {                             
4001c630:	80 a0 a0 0c 	cmp  %g2, 0xc                                  <== NOT EXECUTED
4001c634:	12 bf ff fa 	bne  4001c61c <msdos_date_unix2dos+0xd4>       <== NOT EXECUTED
4001c638:	90 22 00 03 	sub  %o0, %g3, %o0                             <== NOT EXECUTED
4001c63c:	84 10 21 a0 	mov  0x1a0, %g2                                <== NOT EXECUTED
				if (days < months[month])                                         
					break;                                                           
				days -= months[month];                                            
			}                                                                  
			lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)                     
4001c640:	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)                                                   
4001c644:	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)                     
4001c648:	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)                                                   
4001c64c:	08 80 00 06 	bleu  4001c664 <msdos_date_unix2dos+0x11c>     <== NEVER TAKEN
4001c650:	84 10 00 08 	mov  %o0, %g2                                  
				lastddate += (year - 1980) <<                                     
4001c654:	82 00 78 44 	add  %g1, -1980, %g1                           
4001c658:	83 28 60 09 	sll  %g1, 9, %g1                               
4001c65c:	90 02 00 01 	add  %o0, %g1, %o0                             
4001c660:	84 10 00 08 	mov  %o0, %g2                                  
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
4001c664:	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) <<                                     
4001c668:	03 10 00 bd 	sethi  %hi(0x4002f400), %g1                    
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
	*ddp = lastddate;                                                    
4001c66c:	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) <<                                     
4001c670:	d0 30 60 e8 	sth  %o0, [ %g1 + 0xe8 ]                       
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
	*ddp = lastddate;                                                    
4001c674:	81 c7 e0 08 	ret                                            
4001c678:	81 e8 00 00 	restore                                        
				inc = year & 0x03 ? 365 : 366;                                    
				if (days < inc)                                                   
					break;                                                           
				days -= inc;                                                      
			}                                                                  
			months = year & 0x03 ? regyear : leapyear;                         
4001c67c:	10 bf ff e7 	b  4001c618 <msdos_date_unix2dos+0xd0>         
4001c680:	88 11 21 30 	or  %g4, 0x130, %g4                            
4001c684:	10 bf ff ef 	b  4001c640 <msdos_date_unix2dos+0xf8>         
4001c688:	85 28 a0 05 	sll  %g2, 5, %g2                               
4001c68c:	03 10 00 bd 	sethi  %hi(0x4002f400), %g1                    
4001c690:	fa 10 60 e0 	lduh  [ %g1 + 0xe0 ], %i5	! 4002f4e0 <lastdtime>
4001c694:	03 10 00 bd 	sethi  %hi(0x4002f400), %g1                    
4001c698:	c4 10 60 e8 	lduh  [ %g1 + 0xe8 ], %g2	! 4002f4e8 <lastddate>
			if (year > 1980)                                                   
				lastddate += (year - 1980) <<                                     
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
4001c69c:	fa 36 80 00 	sth  %i5, [ %i2 ]                              
	*ddp = lastddate;                                                    
4001c6a0:	c4 36 40 00 	sth  %g2, [ %i1 ]                              
4001c6a4:	81 c7 e0 08 	ret                                            
4001c6a8:	81 e8 00 00 	restore                                        
4001c6ac:	c4 10 60 e8 	lduh  [ %g1 + 0xe8 ], %g2                      
			if (year > 1980)                                                   
				lastddate += (year - 1980) <<                                     
				             MSDOS_DD_YEAR_SHIFT;                                 
		}                                                                   
	}                                                                    
	*dtp = lastdtime;                                                    
4001c6b0:	fa 36 80 00 	sth  %i5, [ %i2 ]                              
	*ddp = lastddate;                                                    
4001c6b4:	c4 36 40 00 	sth  %g2, [ %i1 ]                              
4001c6b8:	81 c7 e0 08 	ret                                            
4001c6bc:	81 e8 00 00 	restore                                        
                                                                      

40019e68 <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 ) {
40019e68:	9d e3 bf a0 	save  %sp, -96, %sp                            
    ssize_t          ret = 0;                                         
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
40019e6c:	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,     
40019e70:	25 10 00 b8 	sethi  %hi(0x4002e000), %l2                    
40019e74:	e2 14 00 00 	lduh  [ %l0 ], %l1                             
40019e78:	ea 04 20 a0 	ld  [ %l0 + 0xa0 ], %l5                        
                         MSDOS_SHORT_NAME_LEN) == 0) ||               
                (strncmp(MSDOS_DIR_NAME((entry)),                     
40019e7c:	29 10 00 b8 	sethi  %hi(0x4002e000), %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;                                                 
40019e80:	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;                                    
40019e84:	a6 10 20 00 	clr  %l3                                       
40019e88:	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,     
40019e8c:	a4 14 a3 68 	or  %l2, 0x368, %l2                            
                         MSDOS_SHORT_NAME_LEN) == 0) ||               
                (strncmp(MSDOS_DIR_NAME((entry)),                     
40019e90:	a8 15 23 78 	or  %l4, 0x378, %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,
40019e94:	a3 34 60 10 	srl  %l1, 0x10, %l1                            
40019e98:	92 10 00 13 	mov  %l3, %o1                                  
40019e9c:	7f ff a1 bc 	call  4000258c <.umul>                         
40019ea0:	90 10 00 11 	mov  %l1, %o0                                  
40019ea4:	92 10 00 19 	mov  %i1, %o1                                  
40019ea8:	94 10 00 08 	mov  %o0, %o2                                  
40019eac:	96 10 00 11 	mov  %l1, %o3                                  
40019eb0:	90 10 00 10 	mov  %l0, %o0                                  
40019eb4:	7f ff e6 b1 	call  40013978 <fat_file_read>                 
40019eb8:	98 10 00 15 	mov  %l5, %o4                                  
40019ebc:	80 a2 20 00 	cmp  %o0, 0                                    
40019ec0:	02 80 00 34 	be  40019f90 <msdos_dir_is_empty+0x128>        <== NEVER TAKEN
40019ec4:	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)                  
40019ec8:	04 80 00 27 	ble  40019f64 <msdos_dir_is_empty+0xfc>        <== NEVER TAKEN
40019ecc:	b0 10 3f ff 	mov  -1, %i0                                   
            return -1;                                                
                                                                      
        assert(ret == fs_info->fat.vol.bps);                          
40019ed0:	e2 14 00 00 	lduh  [ %l0 ], %l1                             
40019ed4:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
40019ed8:	b1 34 60 10 	srl  %l1, 0x10, %i0                            
40019edc:	80 a6 00 08 	cmp  %i0, %o0                                  
40019ee0:	12 80 00 2e 	bne  40019f98 <msdos_dir_is_empty+0x130>       <== NEVER TAKEN
40019ee4:	80 a6 20 00 	cmp  %i0, 0                                    
                                                                      
        /* have to look at the DIR_NAME as "raw" 8-bit data */        
        for (i = 0;                                                   
40019ee8:	02 80 00 27 	be  40019f84 <msdos_dir_is_empty+0x11c>        <== NEVER TAKEN
40019eec:	b8 10 20 00 	clr  %i4                                       
40019ef0:	ea 04 20 a0 	ld  [ %l0 + 0xa0 ], %l5                        
40019ef4:	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)) ==                    
40019ef8:	f6 0f 40 00 	ldub  [ %i5 ], %i3                             
40019efc:	80 a6 e0 e5 	cmp  %i3, 0xe5                                 
40019f00:	22 80 00 1c 	be,a   40019f70 <msdos_dir_is_empty+0x108>     <== NEVER TAKEN
40019f04:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== NOT EXECUTED
                 MSDOS_THIS_DIR_ENTRY_EMPTY) ||                       
                ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==    
40019f08:	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) ||                       
40019f0c:	82 08 60 3f 	and  %g1, 0x3f, %g1                            
40019f10:	80 a0 60 0f 	cmp  %g1, 0xf                                  
40019f14:	02 80 00 16 	be  40019f6c <msdos_dir_is_empty+0x104>        <== NEVER TAKEN
40019f18:	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,     
40019f1c:	92 10 00 12 	mov  %l2, %o1                                  
40019f20:	40 00 14 91 	call  4001f164 <strncmp>                       
40019f24:	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) ||                                   
40019f28:	80 a2 20 00 	cmp  %o0, 0                                    
40019f2c:	22 80 00 11 	be,a   40019f70 <msdos_dir_is_empty+0x108>     
40019f30:	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)),                     
40019f34:	90 10 00 1d 	mov  %i5, %o0                                  
40019f38:	92 10 00 14 	mov  %l4, %o1                                  
40019f3c:	40 00 14 8a 	call  4001f164 <strncmp>                       
40019f40:	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) ||               
40019f44:	80 a2 20 00 	cmp  %o0, 0                                    
40019f48:	22 80 00 0a 	be,a   40019f70 <msdos_dir_is_empty+0x108>     
40019f4c:	b8 07 20 20 	add  %i4, 0x20, %i4                            
                continue;                                             
                                                                      
            /*                                                        
             * Nothing more to look at.                               
             */                                                       
            if ((*MSDOS_DIR_NAME(entry)) ==                           
40019f50:	80 a6 e0 00 	cmp  %i3, 0                                    
40019f54:	12 80 00 04 	bne  40019f64 <msdos_dir_is_empty+0xfc>        
40019f58:	b0 10 20 00 	clr  %i0                                       
             */                                                       
            return RC_OK;                                             
        }                                                             
        j++;                                                          
    }                                                                 
    *ret_val = true;                                                  
40019f5c:	82 10 20 01 	mov  1, %g1                                    
40019f60:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              
    return RC_OK;                                                     
40019f64:	81 c7 e0 08 	ret                                            
40019f68:	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)                  
40019f6c:	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;                                                   
40019f70:	80 a7 00 18 	cmp  %i4, %i0                                  
40019f74:	0a bf ff e1 	bcs  40019ef8 <msdos_dir_is_empty+0x90>        <== ALWAYS TAKEN
40019f78:	ba 07 60 20 	add  %i5, 0x20, %i5                            
            /*                                                        
             * Short file name entries mean not empty.                
             */                                                       
            return RC_OK;                                             
        }                                                             
        j++;                                                          
40019f7c:	10 bf ff c6 	b  40019e94 <msdos_dir_is_empty+0x2c>          <== NOT EXECUTED
40019f80:	a6 04 e0 01 	inc  %l3                                       <== NOT EXECUTED
40019f84:	ea 04 20 a0 	ld  [ %l0 + 0xa0 ], %l5                        <== NOT EXECUTED
40019f88:	10 bf ff c3 	b  40019e94 <msdos_dir_is_empty+0x2c>          <== NOT EXECUTED
40019f8c:	a6 04 e0 01 	inc  %l3                                       <== NOT EXECUTED
    }                                                                 
    *ret_val = true;                                                  
    return RC_OK;                                                     
40019f90:	10 bf ff f3 	b  40019f5c <msdos_dir_is_empty+0xf4>          <== NOT EXECUTED
40019f94:	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);                          
40019f98:	11 10 00 b8 	sethi  %hi(0x4002e000), %o0                    <== NOT EXECUTED
40019f9c:	15 10 00 b8 	sethi  %hi(0x4002e000), %o2                    <== NOT EXECUTED
40019fa0:	17 10 00 b8 	sethi  %hi(0x4002e000), %o3                    <== NOT EXECUTED
40019fa4:	90 12 22 f8 	or  %o0, 0x2f8, %o0                            <== NOT EXECUTED
40019fa8:	92 10 23 65 	mov  0x365, %o1                                <== NOT EXECUTED
40019fac:	94 12 a3 b0 	or  %o2, 0x3b0, %o2                            <== NOT EXECUTED
40019fb0:	7f ff af 13 	call  40005bfc <__assert_func>                 <== NOT EXECUTED
40019fb4:	96 12 e3 48 	or  %o3, 0x348, %o3                            <== NOT EXECUTED
                                                                      

4001c9fc <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) {
4001c9fc:	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;     
4001ca00:	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);                      
4001ca04:	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;            
4001ca08:	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);                      
4001ca0c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4001ca10:	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)        
{                                                                     
4001ca14:	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;                             
4001ca18:	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;     
4001ca1c:	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);                      
4001ca20:	7f ff 95 f0 	call  400021e0 <__divdi3>                      <== NOT EXECUTED
4001ca24:	c0 27 be d4 	clr  [ %fp + -300 ]                            <== NOT EXECUTED
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);  
4001ca28:	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);                      
4001ca2c:	b6 10 00 09 	mov  %o1, %i3                                  <== NOT EXECUTED
    count = (count / sizeof(struct dirent)) * sizeof(struct dirent);  
4001ca30:	7f ff 97 11 	call  40002674 <.udiv>                         <== NOT EXECUTED
4001ca34:	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                              :     
4001ca38:	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);  
4001ca3c:	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                              :     
4001ca40:	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);  
4001ca44:	91 2a 20 05 	sll  %o0, 5, %o0                               <== NOT EXECUTED
4001ca48:	90 04 40 08 	add  %l1, %o0, %o0                             <== NOT EXECUTED
4001ca4c:	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                              :     
4001ca50:	02 80 00 f2 	be  4001ce18 <msdos_dir_read+0x41c>            <== NOT EXECUTED
4001ca54:	a2 24 40 08 	sub  %l1, %o0, %l1                             <== NOT EXECUTED
4001ca58:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         <== NOT EXECUTED
4001ca5c:	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,        
4001ca60:	d0 06 20 9c 	ld  [ %i0 + 0x9c ], %o0                        <== NOT EXECUTED
4001ca64:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001ca68:	7f ff b6 e4 	call  4000a5f8 <rtems_semaphore_obtain>        <== NOT EXECUTED
4001ca6c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001ca70:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001ca74:	12 80 01 37 	bne  4001cf50 <msdos_dir_read+0x554>           <== NOT EXECUTED
4001ca78:	80 a4 60 00 	cmp  %l1, 0                                    <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    while (count > 0)                                                 
4001ca7c:	02 80 00 3a 	be  4001cb64 <msdos_dir_read+0x168>            <== NOT EXECUTED
4001ca80:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
4001ca84:	a6 10 20 00 	clr  %l3                                       <== NOT EXECUTED
4001ca88:	a8 10 20 00 	clr  %l4                                       <== NOT EXECUTED
4001ca8c:	c0 2f be cf 	clrb  [ %fp + -305 ]                           <== NOT EXECUTED
4001ca90:	b4 10 3f ff 	mov  -1, %i2                                   <== NOT EXECUTED
4001ca94:	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),      
4001ca98:	d8 06 20 a0 	ld  [ %i0 + 0xa0 ], %o4                        <== NOT EXECUTED
4001ca9c:	d6 07 be c4 	ld  [ %fp + -316 ], %o3                        <== NOT EXECUTED
4001caa0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001caa4:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
4001caa8:	7f ff db b4 	call  40013978 <fat_file_read>                 <== NOT EXECUTED
4001caac:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
                            bts2rd, fs_info->cl_buf);                 
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
4001cab0:	80 a2 20 1f 	cmp  %o0, 0x1f                                 <== NOT EXECUTED
4001cab4:	04 80 01 1e 	ble  4001cf2c <msdos_dir_read+0x530>           <== NOT EXECUTED
4001cab8:	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;                
4001cabc:	fa 06 20 a0 	ld  [ %i0 + 0xa0 ], %i5                        <== NOT EXECUTED
                                                                      
            /*                                                        
             * Is this directory from here on empty ?                 
             */                                                       
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
4001cac0:	c4 0f 40 00 	ldub  [ %i5 ], %g2                             <== NOT EXECUTED
4001cac4:	86 88 a0 ff 	andcc  %g2, 0xff, %g3                          <== NOT EXECUTED
4001cac8:	02 80 00 ce 	be  4001ce00 <msdos_dir_read+0x404>            <== NOT EXECUTED
4001cacc:	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)
4001cad0:	10 80 00 0f 	b  4001cb0c <msdos_dir_read+0x110>             <== NOT EXECUTED
4001cad4:	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) &&  
4001cad8:	80 a0 e0 0f 	cmp  %g3, 0xf                                  <== NOT EXECUTED
4001cadc:	02 80 00 28 	be  4001cb7c <msdos_dir_read+0x180>            <== NOT EXECUTED
4001cae0:	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)  
4001cae4:	ae 05 e0 20 	add  %l7, 0x20, %l7                            <== NOT EXECUTED
4001cae8:	80 a5 c0 16 	cmp  %l7, %l6                                  <== NOT EXECUTED
4001caec:	1a 80 00 1a 	bcc  4001cb54 <msdos_dir_read+0x158>           <== NOT EXECUTED
4001caf0:	c2 07 be c4 	ld  [ %fp + -316 ], %g1                        <== NOT EXECUTED
        {                                                             
            char* entry = (char*) fs_info->cl_buf + i;                
4001caf4:	fa 06 20 a0 	ld  [ %i0 + 0xa0 ], %i5                        <== NOT EXECUTED
                                                                      
            /*                                                        
             * Is this directory from here on empty ?                 
             */                                                       
            if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==                     
4001caf8:	c4 0f 40 17 	ldub  [ %i5 + %l7 ], %g2                       <== NOT EXECUTED
4001cafc:	86 88 a0 ff 	andcc  %g2, 0xff, %g3                          <== NOT EXECUTED
4001cb00:	02 80 00 c0 	be  4001ce00 <msdos_dir_read+0x404>            <== NOT EXECUTED
4001cb04:	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)
4001cb08:	80 a0 e0 e5 	cmp  %g3, 0xe5                                 <== NOT EXECUTED
4001cb0c:	22 bf ff f7 	be,a   4001cae8 <msdos_dir_read+0xec>          <== NOT EXECUTED
4001cb10:	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) &&  
4001cb14:	c6 0f 60 0b 	ldub  [ %i5 + 0xb ], %g3                       <== NOT EXECUTED
4001cb18:	b8 08 e0 08 	and  %g3, 8, %i4                               <== NOT EXECUTED
4001cb1c:	80 8f 20 ff 	btst  0xff, %i4                                <== NOT EXECUTED
4001cb20:	12 bf ff ee 	bne  4001cad8 <msdos_dir_read+0xdc>            <== NOT EXECUTED
4001cb24:	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) ==     
4001cb28:	80 a0 e0 0f 	cmp  %g3, 0xf                                  <== NOT EXECUTED
4001cb2c:	02 80 00 13 	be  4001cb78 <msdos_dir_read+0x17c>            <== NOT EXECUTED
4001cb30:	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)                                            
4001cb34:	02 80 00 3c 	be  4001cc24 <msdos_dir_read+0x228>            <== NOT EXECUTED
4001cb38:	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)  
4001cb3c:	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--;                                          
4001cb40:	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)  
4001cb44:	80 a5 c0 16 	cmp  %l7, %l6                                  <== NOT EXECUTED
4001cb48:	0a bf ff eb 	bcs  4001caf4 <msdos_dir_read+0xf8>            <== NOT EXECUTED
4001cb4c:	b4 10 3f ff 	mov  -1, %i2                                   <== NOT EXECUTED
4001cb50:	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)                                                 
4001cb54:	80 a4 60 00 	cmp  %l1, 0                                    <== NOT EXECUTED
4001cb58:	12 bf ff d0 	bne  4001ca98 <msdos_dir_read+0x9c>            <== NOT EXECUTED
4001cb5c:	a6 04 c0 01 	add  %l3, %g1, %l3                             <== NOT EXECUTED
4001cb60:	b8 10 00 10 	mov  %l0, %i4                                  <== NOT EXECUTED
                break;                                                
        }                                                             
        j++;                                                          
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001cb64:	d0 06 20 9c 	ld  [ %i0 + 0x9c ], %o0                        <== NOT EXECUTED
4001cb68:	7f ff b6 f3 	call  4000a734 <rtems_semaphore_release>       <== NOT EXECUTED
4001cb6c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
    return cmpltd;                                                    
}                                                                     
4001cb70:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001cb74:	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)                 
4001cb78:	80 a6 bf ff 	cmp  %i2, -1                                   <== NOT EXECUTED
4001cb7c:	02 80 00 93 	be  4001cdc8 <msdos_dir_read+0x3cc>            <== NOT EXECUTED
4001cb80:	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) &   
4001cb84:	c4 0f 40 00 	ldub  [ %i5 ], %g2                             <== NOT EXECUTED
4001cb88:	84 08 a0 3f 	and  %g2, 0x3f, %g2                            <== NOT EXECUTED
4001cb8c:	80 a0 80 14 	cmp  %g2, %l4                                  <== NOT EXECUTED
4001cb90:	22 80 00 04 	be,a   4001cba0 <msdos_dir_read+0x1a4>         <== NOT EXECUTED
4001cb94:	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;                  
4001cb98:	10 bf ff d3 	b  4001cae4 <msdos_dir_read+0xe8>              <== NOT EXECUTED
4001cb9c:	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)) ||  
4001cba0:	c4 0f be cf 	ldub  [ %fp + -305 ], %g2                      <== NOT EXECUTED
4001cba4:	86 0b 20 ff 	and  %o4, 0xff, %g3                            <== NOT EXECUTED
4001cba8:	80 a0 c0 02 	cmp  %g3, %g2                                  <== NOT EXECUTED
4001cbac:	32 bf ff ce 	bne,a   4001cae4 <msdos_dir_read+0xe8>         <== NOT EXECUTED
4001cbb0:	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--;                                        
4001cbb4:	a8 05 3f ff 	add  %l4, -1, %l4                              <== NOT EXECUTED
                p = entry + 1;                                        
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
4001cbb8:	85 2d 20 02 	sll  %l4, 2, %g2                               <== NOT EXECUTED
4001cbbc:	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;                                        
4001cbc0:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
                o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;            
4001cbc4:	94 22 80 02 	sub  %o2, %g2, %o2                             <== NOT EXECUTED
4001cbc8:	b8 10 20 01 	mov  1, %i4                                    <== NOT EXECUTED
4001cbcc:	94 02 80 14 	add  %o2, %l4, %o2                             <== NOT EXECUTED
4001cbd0:	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)        
4001cbd4:	82 07 be e8 	add  %fp, -280, %g1                            <== NOT EXECUTED
4001cbd8:	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))         
4001cbdc:	80 a0 a0 fe 	cmp  %g2, 0xfe                                 <== NOT EXECUTED
4001cbe0:	18 80 00 99 	bgu  4001ce44 <msdos_dir_read+0x448>           <== NOT EXECUTED
4001cbe4:	9e 00 40 02 	add  %g1, %g2, %o7                             <== NOT EXECUTED
                        break;                                        
                                                                      
                    tmp_dirent.d_name[o++] = *p;                      
4001cbe8:	d6 0f 40 00 	ldub  [ %i5 ], %o3                             <== NOT EXECUTED
4001cbec:	d6 2b e0 14 	stb  %o3, [ %o7 + 0x14 ]                       <== NOT EXECUTED
                                                                      
                    if (*p == '\0')                                   
4001cbf0:	de 4f 40 00 	ldsb  [ %i5 ], %o7                             <== NOT EXECUTED
4001cbf4:	80 a3 e0 00 	cmp  %o7, 0                                    <== NOT EXECUTED
4001cbf8:	02 80 00 93 	be  4001ce44 <msdos_dir_read+0x448>            <== NOT EXECUTED
4001cbfc:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
                        break;                                        
                                                                      
                    switch (q)                                        
4001cc00:	80 a0 e0 04 	cmp  %g3, 4                                    <== NOT EXECUTED
4001cc04:	02 80 00 92 	be  4001ce4c <msdos_dir_read+0x450>            <== NOT EXECUTED
4001cc08:	80 a0 e0 0a 	cmp  %g3, 0xa                                  <== NOT EXECUTED
4001cc0c:	02 80 00 93 	be  4001ce58 <msdos_dir_read+0x45c>            <== NOT EXECUTED
4001cc10:	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++)         
4001cc14:	02 80 00 8c 	be  4001ce44 <msdos_dir_read+0x448>            <== NOT EXECUTED
4001cc18:	ba 07 60 02 	add  %i5, 2, %i5                               <== NOT EXECUTED
4001cc1c:	10 bf ff ef 	b  4001cbd8 <msdos_dir_read+0x1dc>             <== NOT EXECUTED
4001cc20:	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, 
4001cc24:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
4001cc28:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
4001cc2c:	96 10 00 13 	mov  %l3, %o3                                  <== NOT EXECUTED
4001cc30:	7f ff dc 46 	call  40013d48 <fat_file_ioctl>                <== NOT EXECUTED
4001cc34:	98 07 be d4 	add  %fp, -300, %o4                            <== NOT EXECUTED
                                    j * bts2rd, &cur_cln);            
                if (rc != RC_OK)                                      
4001cc38:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
4001cc3c:	12 bf ff ca 	bne  4001cb64 <msdos_dir_read+0x168>           <== NOT EXECUTED
4001cc40:	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;                           
4001cc44:	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;                          
4001cc48:	c4 27 be d8 	st  %g2, [ %fp + -296 ]                        <== NOT EXECUTED
4001cc4c:	c2 27 be e0 	st  %g1, [ %fp + -288 ]                        <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
4001cc50:	c2 27 be e4 	st  %g1, [ %fp + -284 ]                        <== NOT EXECUTED
                dir_pos.sname.ofs = i;                                
4001cc54:	ee 27 be dc 	st  %l7, [ %fp + -292 ]                        <== NOT EXECUTED
                rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
4001cc58:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001cc5c:	92 07 be d8 	add  %fp, -296, %o1                            <== NOT EXECUTED
4001cc60:	7f ff da 92 	call  400136a8 <fat_file_open>                 <== NOT EXECUTED
4001cc64:	94 07 be d0 	add  %fp, -304, %o2                            <== NOT EXECUTED
                if (rc != RC_OK)                                      
4001cc68:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
4001cc6c:	12 bf ff be 	bne  4001cb64 <msdos_dir_read+0x168>           <== NOT EXECUTED
4001cc70:	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);          
4001cc74:	82 10 21 18 	mov  0x118, %g1                                <== NOT EXECUTED
                tmp_dirent.d_ino = tmp_fat_fd->ino;                   
4001cc78:	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;                    
4001cc7c:	c0 27 be f0 	clr  [ %fp + -272 ]                            <== NOT EXECUTED
4001cc80:	e0 27 be f4 	st  %l0, [ %fp + -268 ]                        <== NOT EXECUTED
                tmp_dirent.d_reclen = sizeof(struct dirent);          
4001cc84:	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)                 
4001cc88:	80 a6 bf ff 	cmp  %i2, -1                                   <== NOT EXECUTED
4001cc8c:	02 80 00 35 	be  4001cd60 <msdos_dir_read+0x364>            <== NOT EXECUTED
4001cc90:	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)        
4001cc94:	9e 07 60 0b 	add  %i5, 0xb, %o7                             <== NOT EXECUTED
4001cc98:	84 10 00 1d 	mov  %i5, %g2                                  <== NOT EXECUTED
4001cc9c:	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;  
4001cca0:	10 80 00 06 	b  4001ccb8 <msdos_dir_read+0x2bc>             <== NOT EXECUTED
4001cca4:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
4001cca8:	80 a0 00 0c 	cmp  %g0, %o4                                  <== NOT EXECUTED
4001ccac:	86 40 3f ff 	addx  %g0, -1, %g3                             <== NOT EXECUTED
4001ccb0:	86 08 e0 80 	and  %g3, 0x80, %g3                            <== NOT EXECUTED
4001ccb4:	86 00 ff 80 	add  %g3, -128, %g3                            <== NOT EXECUTED
4001ccb8:	d8 08 80 00 	ldub  [ %g2 ], %o4                             <== NOT EXECUTED
4001ccbc:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            <== NOT EXECUTED
4001ccc0:	b9 37 20 01 	srl  %i4, 1, %i4                               <== NOT EXECUTED
4001ccc4:	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++)                     
4001ccc8:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
4001cccc:	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++)                     
4001ccd0:	80 a0 80 0f 	cmp  %g2, %o7                                  <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
4001ccd4:	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++)                     
4001ccd8:	12 bf ff f4 	bne  4001cca8 <msdos_dir_read+0x2ac>           <== NOT EXECUTED
4001ccdc:	b8 10 00 03 	mov  %g3, %i4                                  <== NOT EXECUTED
                        cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;  
                                                                      
                    if (lfn_entries || (lfn_checksum != cs))          
4001cce0:	c2 0f be cf 	ldub  [ %fp + -305 ], %g1                      <== NOT EXECUTED
4001cce4:	b8 18 40 1c 	xor  %g1, %i4, %i4                             <== NOT EXECUTED
4001cce8:	80 8f 20 ff 	btst  0xff, %i4                                <== NOT EXECUTED
4001ccec:	12 80 00 1e 	bne  4001cd64 <msdos_dir_read+0x368>           <== NOT EXECUTED
4001ccf0:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001ccf4:	80 a5 20 00 	cmp  %l4, 0                                    <== NOT EXECUTED
4001ccf8:	32 80 00 1c 	bne,a   4001cd68 <msdos_dir_read+0x36c>        <== NOT EXECUTED
4001ccfc:	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);  
4001cd00:	40 00 08 e7 	call  4001f09c <strlen>                        <== NOT EXECUTED
4001cd04:	90 07 be fc 	add  %fp, -260, %o0                            <== NOT EXECUTED
4001cd08:	d0 37 be fa 	sth  %o0, [ %fp + -262 ]                       <== NOT EXECUTED
                }                                                     
                                                                      
                memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
4001cd0c:	90 06 40 10 	add  %i1, %l0, %o0                             <== NOT EXECUTED
4001cd10:	92 07 be e8 	add  %fp, -280, %o1                            <== NOT EXECUTED
4001cd14:	40 00 04 c4 	call  4001e024 <memcpy>                        <== NOT EXECUTED
4001cd18:	94 10 21 18 	mov  0x118, %o2                                <== NOT EXECUTED
                                                                      
                iop->offset = iop->offset + sizeof(struct dirent);    
4001cd1c:	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);       
4001cd20:	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);    
4001cd24:	ba 80 e1 18 	addcc  %g3, 0x118, %i5                         <== NOT EXECUTED
4001cd28:	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);       
4001cd2c:	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);    
4001cd30:	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);       
4001cd34:	7f ff db d7 	call  40013c90 <fat_file_close>                <== NOT EXECUTED
4001cd38:	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));                     
4001cd3c:	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)                                      
4001cd40:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001cd44:	12 bf ff 88 	bne  4001cb64 <msdos_dir_read+0x168>           <== NOT EXECUTED
4001cd48:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
                    rtems_semaphore_release(fs_info->vol_sema);       
                    return rc;                                        
                }                                                     
            }                                                         
                                                                      
            if (count <= 0)                                           
4001cd4c:	80 a4 60 00 	cmp  %l1, 0                                    <== NOT EXECUTED
4001cd50:	32 bf ff 66 	bne,a   4001cae8 <msdos_dir_read+0xec>         <== NOT EXECUTED
4001cd54:	ae 05 e0 20 	add  %l7, 0x20, %l7                            <== NOT EXECUTED
4001cd58:	10 bf ff 83 	b  4001cb64 <msdos_dir_read+0x168>             <== NOT EXECUTED
4001cd5c:	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  ,                       
4001cd60:	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)        
4001cd64:	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) &&                                                    
4001cd68:	c4 4e bf ff 	ldsb  [ %i2 + -1 ], %g2                        <== NOT EXECUTED
4001cd6c:	80 a0 a0 20 	cmp  %g2, 0x20                                 <== NOT EXECUTED
4001cd70:	12 80 00 3d 	bne  4001ce64 <msdos_dir_read+0x468>           <== NOT EXECUTED
4001cd74:	03 10 00 bb 	sethi  %hi(0x4002ec00), %g1                    <== NOT EXECUTED
  const char *src_tmp;                                                
                                                                      
  /*                                                                  
   * find last non-blank character of base name                       
   */                                                                 
  for ((i       =       MSDOS_SHORT_BASE_LEN  ,                       
4001cd78:	92 82 7f ff 	addcc  %o1, -1, %o1                            <== NOT EXECUTED
4001cd7c:	32 bf ff fb 	bne,a   4001cd68 <msdos_dir_read+0x36c>        <== NOT EXECUTED
4001cd80:	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(
4001cd84:	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) &&                                                    
4001cd88:	c4 4f 60 0a 	ldsb  [ %i5 + 0xa ], %g2                       <== NOT EXECUTED
4001cd8c:	80 a0 a0 20 	cmp  %g2, 0x20                                 <== NOT EXECUTED
4001cd90:	12 80 00 46 	bne  4001cea8 <msdos_dir_read+0x4ac>           <== NOT EXECUTED
4001cd94:	98 10 20 03 	mov  3, %o4                                    <== NOT EXECUTED
4001cd98:	c4 4f 60 09 	ldsb  [ %i5 + 9 ], %g2                         <== NOT EXECUTED
4001cd9c:	80 a0 a0 20 	cmp  %g2, 0x20                                 <== NOT EXECUTED
4001cda0:	32 80 00 42 	bne,a   4001cea8 <msdos_dir_read+0x4ac>        <== NOT EXECUTED
4001cda4:	98 10 20 02 	mov  2, %o4                                    <== NOT EXECUTED
4001cda8:	c4 4f 60 08 	ldsb  [ %i5 + 8 ], %g2                         <== NOT EXECUTED
4001cdac:	80 a0 a0 20 	cmp  %g2, 0x20                                 <== NOT EXECUTED
4001cdb0:	12 80 00 3e 	bne  4001cea8 <msdos_dir_read+0x4ac>           <== NOT EXECUTED
4001cdb4:	98 10 20 01 	mov  1, %o4                                    <== NOT EXECUTED
    while (i-- > 0) {                                                 
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
      len++;                                                          
    }                                                                 
  }                                                                   
  *dst = '\0'; /* terminate string */                                 
4001cdb8:	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(
4001cdbc:	d2 37 be fa 	sth  %o1, [ %fp + -262 ]                       <== NOT EXECUTED
4001cdc0:	10 bf ff d3 	b  4001cd0c <msdos_dir_read+0x310>             <== NOT EXECUTED
4001cdc4:	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) &               
4001cdc8:	80 88 e0 ff 	btst  0xff, %g3                                <== NOT EXECUTED
4001cdcc:	22 bf ff 47 	be,a   4001cae8 <msdos_dir_read+0xec>          <== NOT EXECUTED
4001cdd0:	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);    
4001cdd4:	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)        
4001cdd8:	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) &     
4001cddc:	a8 08 a0 3f 	and  %g2, 0x3f, %l4                            <== NOT EXECUTED
                        continue;                                     
                                                                      
                    /*                                                
                     * Remember the start location of the long file name.
                     */                                               
                    lfn_start =                                       
4001cde0:	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);    
4001cde4:	c2 2f be cf 	stb  %g1, [ %fp + -305 ]                       <== NOT EXECUTED
                    memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
4001cde8:	90 07 be fc 	add  %fp, -260, %o0                            <== NOT EXECUTED
4001cdec:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001cdf0:	40 00 04 ca 	call  4001e118 <memset>                        <== NOT EXECUTED
4001cdf4:	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) &   
4001cdf8:	10 bf ff 64 	b  4001cb88 <msdos_dir_read+0x18c>             <== NOT EXECUTED
4001cdfc:	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);           
4001ce00:	d0 06 20 9c 	ld  [ %i0 + 0x9c ], %o0                        <== NOT EXECUTED
4001ce04:	7f ff b6 4c 	call  4000a734 <rtems_semaphore_release>       <== NOT EXECUTED
4001ce08:	b8 10 00 10 	mov  %l0, %i4                                  <== NOT EXECUTED
        j++;                                                          
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return cmpltd;                                                    
}                                                                     
4001ce0c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4001ce10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ce14:	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) &&                           
4001ce18:	c2 05 60 24 	ld  [ %l5 + 0x24 ], %g1                        <== NOT EXECUTED
4001ce1c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001ce20:	32 bf ff 0f 	bne,a   4001ca5c <msdos_dir_read+0x60>         <== NOT EXECUTED
4001ce24:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         <== NOT EXECUTED
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
4001ce28:	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) &&                           
4001ce2c:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
4001ce30:	22 bf ff 0b 	be,a   4001ca5c <msdos_dir_read+0x60>          <== NOT EXECUTED
4001ce34:	c2 16 20 06 	lduh  [ %i0 + 6 ], %g1                         <== NOT EXECUTED
             (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?     
             fat_fd->fat_file_size                              :     
4001ce38:	c2 05 60 18 	ld  [ %l5 + 0x18 ], %g1                        <== NOT EXECUTED
4001ce3c:	10 bf ff 09 	b  4001ca60 <msdos_dir_read+0x64>              <== NOT EXECUTED
4001ce40:	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')                                   
4001ce44:	10 bf ff c2 	b  4001cd4c <msdos_dir_read+0x350>             <== NOT EXECUTED
4001ce48:	d8 2f be cf 	stb  %o4, [ %fp + -305 ]                       <== NOT EXECUTED
                        break;                                        
                                                                      
                    switch (q)                                        
                    {                                                 
                        case 4:                                       
                            p += 5;                                   
4001ce4c:	ba 07 60 05 	add  %i5, 5, %i5                               <== NOT EXECUTED
4001ce50:	10 bf ff 61 	b  4001cbd4 <msdos_dir_read+0x1d8>             <== NOT EXECUTED
4001ce54:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
                            break;                                    
                        case 10:                                      
                            p += 4;                                   
4001ce58:	ba 07 60 04 	add  %i5, 4, %i5                               <== NOT EXECUTED
4001ce5c:	10 bf ff 5e 	b  4001cbd4 <msdos_dir_read+0x1d8>             <== NOT EXECUTED
4001ce60:	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)        
4001ce64:	84 10 00 1d 	mov  %i5, %g2                                  <== NOT EXECUTED
4001ce68:	d8 00 61 48 	ld  [ %g1 + 0x148 ], %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(
4001ce6c:	10 80 00 06 	b  4001ce84 <msdos_dir_read+0x488>             <== NOT EXECUTED
4001ce70:	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++));                    
4001ce74:	f8 28 c0 00 	stb  %i4, [ %g3 ]                              <== NOT EXECUTED
  /*                                                                  
   * copy base name to destination                                    
   */                                                                 
  src_tmp = src;                                                      
  len = i;                                                            
  while (i-- > 0) {                                                   
4001ce78:	80 a0 80 1a 	cmp  %g2, %i2                                  <== NOT EXECUTED
4001ce7c:	02 bf ff c3 	be  4001cd88 <msdos_dir_read+0x38c>            <== NOT EXECUTED
4001ce80:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
    *dst++ = tolower((unsigned char)(*src_tmp++));                    
4001ce84:	f8 08 80 00 	ldub  [ %g2 ], %i4                             <== NOT EXECUTED
4001ce88:	9e 03 00 1c 	add  %o4, %i4, %o7                             <== NOT EXECUTED
4001ce8c:	de 0b e0 01 	ldub  [ %o7 + 1 ], %o7                         <== NOT EXECUTED
4001ce90:	9e 0b e0 03 	and  %o7, 3, %o7                               <== NOT EXECUTED
4001ce94:	80 a3 e0 01 	cmp  %o7, 1                                    <== NOT EXECUTED
4001ce98:	12 bf ff f7 	bne  4001ce74 <msdos_dir_read+0x478>           <== NOT EXECUTED
4001ce9c:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
4001cea0:	10 bf ff f5 	b  4001ce74 <msdos_dir_read+0x478>             <== NOT EXECUTED
4001cea4:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== NOT EXECUTED
    {};                                                               
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
4001cea8:	82 10 20 2e 	mov  0x2e, %g1                                 <== NOT EXECUTED
4001ceac:	96 00 e0 01 	add  %g3, 1, %o3                               <== NOT EXECUTED
4001ceb0:	c2 28 c0 00 	stb  %g1, [ %g3 ]                              <== NOT EXECUTED
    len += i + 1; /* extension + dot */                               
4001ceb4:	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)        
4001ceb8:	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 */                               
4001cebc:	94 02 40 0a 	add  %o1, %o2, %o2                             <== NOT EXECUTED
    src_tmp = src + MSDOS_SHORT_BASE_LEN;                             
4001cec0:	84 07 60 08 	add  %i5, 8, %g2                               <== NOT EXECUTED
4001cec4:	03 10 00 bb 	sethi  %hi(0x4002ec00), %g1                    <== NOT EXECUTED
    while (i-- > 0) {                                                 
4001cec8:	92 03 3f ff 	add  %o4, -1, %o1                              <== NOT EXECUTED
4001cecc:	de 00 61 48 	ld  [ %g1 + 0x148 ], %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)        
4001ced0:	ba 07 40 1c 	add  %i5, %i4, %i5                             <== NOT EXECUTED
    {};                                                               
  /*                                                                  
   * extension is not empty                                           
   */                                                                 
  if (i > 0) {                                                        
    *dst++ = '.'; /* append dot */                                    
4001ced4:	10 80 00 06 	b  4001ceec <msdos_dir_read+0x4f0>             <== NOT EXECUTED
4001ced8:	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++));                  
4001cedc:	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) {                                                 
4001cee0:	80 a0 80 1d 	cmp  %g2, %i5                                  <== NOT EXECUTED
4001cee4:	02 80 00 0e 	be  4001cf1c <msdos_dir_read+0x520>            <== NOT EXECUTED
4001cee8:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
      *dst++ = tolower((unsigned char)(*src_tmp++));                  
4001ceec:	f8 08 80 00 	ldub  [ %g2 ], %i4                             <== NOT EXECUTED
4001cef0:	b4 03 c0 1c 	add  %o7, %i4, %i2                             <== NOT EXECUTED
4001cef4:	f4 0e a0 01 	ldub  [ %i2 + 1 ], %i2                         <== NOT EXECUTED
4001cef8:	b4 0e a0 03 	and  %i2, 3, %i2                               <== NOT EXECUTED
4001cefc:	80 a6 a0 01 	cmp  %i2, 1                                    <== NOT EXECUTED
4001cf00:	12 bf ff f7 	bne  4001cedc <msdos_dir_read+0x4e0>           <== NOT EXECUTED
4001cf04:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
4001cf08:	b8 07 20 20 	add  %i4, 0x20, %i4                            <== NOT EXECUTED
4001cf0c:	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) {                                                 
4001cf10:	80 a0 80 1d 	cmp  %g2, %i5                                  <== NOT EXECUTED
4001cf14:	12 bf ff f6 	bne  4001ceec <msdos_dir_read+0x4f0>           <== NOT EXECUTED
4001cf18:	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)        
4001cf1c:	94 02 a0 01 	inc  %o2                                       <== NOT EXECUTED
4001cf20:	86 02 c0 0c 	add  %o3, %o4, %g3                             <== NOT EXECUTED
4001cf24:	10 bf ff a5 	b  4001cdb8 <msdos_dir_read+0x3bc>             <== NOT EXECUTED
4001cf28:	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);               
4001cf2c:	d0 06 20 9c 	ld  [ %i0 + 0x9c ], %o0                        <== NOT EXECUTED
4001cf30:	7f ff b6 01 	call  4000a734 <rtems_semaphore_release>       <== NOT EXECUTED
4001cf34:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
            rtems_set_errno_and_return_minus_one(EIO);                
4001cf38:	40 00 01 96 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001cf3c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4001cf40:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001cf44:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001cf48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001cf4c:	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);                    
4001cf50:	40 00 01 90 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001cf54:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
4001cf58:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001cf5c:	10 bf ff ac 	b  4001ce0c <msdos_dir_read+0x410>             <== NOT EXECUTED
4001cf60:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      

4001cf64 <msdos_dir_stat>: int msdos_dir_stat( const rtems_filesystem_location_info_t *loc, struct stat *buf ) {
4001cf64:	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;              
4001cf68:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    fat_file_fd_t     *fat_fd = loc->node_access;                     
4001cf6c:	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;              
4001cf70:	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,        
4001cf74:	92 10 20 00 	clr  %o1                                       
4001cf78:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
4001cf7c:	7f ff b5 9f 	call  4000a5f8 <rtems_semaphore_obtain>        
4001cf80:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001cf84:	80 a2 20 00 	cmp  %o0, 0                                    
4001cf88:	12 80 00 1a 	bne  4001cff0 <msdos_dir_stat+0x8c>            <== NEVER TAKEN
4001cf8c:	01 00 00 00 	nop                                            
                                                                      
static inline dev_t rtems_disk_get_device_identifier(                 
  const rtems_disk_device *dd                                         
)                                                                     
{                                                                     
  return dd->dev;                                                     
4001cf90:	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;                           
4001cf94:	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);
4001cf98:	c4 18 40 00 	ldd  [ %g1 ], %g2                              
    buf->st_ino = fat_fd->ino;                                        
4001cf9c:	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;                             
4001cfa0:	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;                                    
4001cfa4:	c8 07 20 40 	ld  [ %i4 + 0x40 ], %g4                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001cfa8:	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);
4001cfac:	c4 3e 40 00 	std  %g2, [ %i1 ]                              
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
4001cfb0:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
4001cfb4:	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;     
4001cfb8:	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;                                        
4001cfbc:	f4 26 60 08 	st  %i2, [ %i1 + 8 ]                           
    buf->st_mode  = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;            
    buf->st_rdev = 0ll;                                               
4001cfc0:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
4001cfc4:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
    buf->st_size = fat_fd->fat_file_size;                             
4001cfc8:	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;            
4001cfcc:	c4 26 60 0c 	st  %g2, [ %i1 + 0xc ]                         
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
4001cfd0:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
    buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;     
4001cfd4:	fa 26 60 44 	st  %i5, [ %i1 + 0x44 ]                        
    buf->st_blksize = fs_info->fat.vol.bps;                           
4001cfd8:	f6 26 60 40 	st  %i3, [ %i1 + 0x40 ]                        
    buf->st_mtime = fat_fd->mtime;                                    
4001cfdc:	c8 26 60 30 	st  %g4, [ %i1 + 0x30 ]                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001cfe0:	7f ff b5 d5 	call  4000a734 <rtems_semaphore_release>       
4001cfe4:	b0 10 20 00 	clr  %i0                                       
    return RC_OK;                                                     
}                                                                     
4001cfe8:	81 c7 e0 08 	ret                                            
4001cfec:	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);                    
4001cff0:	40 00 01 68 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001cff4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001cff8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001cffc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001d000:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d004:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400196bc <msdos_eval_token>: rtems_filesystem_eval_path_context_t *ctx, void *arg, const char *token, size_t tokenlen ) {
400196bc:	9d e3 bf a0 	save  %sp, -96, %sp                            
400196c0:	80 a6 e0 01 	cmp  %i3, 1                                    
400196c4:	02 80 00 17 	be  40019720 <msdos_eval_token+0x64>           
400196c8:	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);            
400196cc:	90 07 60 18 	add  %i5, 0x18, %o0                            
400196d0:	92 10 00 1a 	mov  %i2, %o1                                  
400196d4:	40 00 06 2e 	call  4001af8c <msdos_find_name>               
400196d8:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
    if (rc == RC_OK) {                                                
400196dc:	80 a2 20 00 	cmp  %o0, 0                                    
400196e0:	12 80 00 17 	bne  4001973c <msdos_eval_token+0x80>          
400196e4:	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)                       
400196e8:	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;                
400196ec:	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)                       
400196f0:	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;                                                  
400196f4:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
400196f8:	80 a0 a0 00 	cmp  %g2, 0                                    
400196fc:	12 80 00 1a 	bne  40019764 <msdos_eval_token+0xa8>          
40019700:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
        loc->handlers = fs_info->directory_handlers;                  
40019704:	c2 00 60 94 	ld  [ %g1 + 0x94 ], %g1                        
40019708:	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)) {                 
4001970c:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
40019710:	80 a0 00 01 	cmp  %g0, %g1                                  
40019714:	b0 60 3f ff 	subx  %g0, -1, %i0                             
40019718:	81 c7 e0 08 	ret                                            
4001971c:	81 e8 00 00 	restore                                        
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
40019720:	c2 4e 80 00 	ldsb  [ %i2 ], %g1                             
40019724:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40019728:	12 bf ff ea 	bne  400196d0 <msdos_eval_token+0x14>          
4001972c:	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;                                                  
40019730:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
      rtems_filesystem_eval_path_error(ctx, 0);                       
    }                                                                 
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
40019734:	81 c7 e0 08 	ret                                            
40019738:	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) {                      
4001973c:	82 10 61 01 	or  %g1, 0x101, %g1                            
40019740:	80 a2 00 01 	cmp  %o0, %g1                                  
40019744:	02 bf ff f5 	be  40019718 <msdos_eval_token+0x5c>           <== ALWAYS TAKEN
40019748:	b0 10 20 02 	mov  2, %i0                                    
      status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;           
    } else {                                                          
      rtems_filesystem_eval_path_error(ctx, 0);                       
4001974c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40019750:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40019754:	7f ff b6 11 	call  40006f98 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40019758:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
4001975c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40019760:	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;                       
40019764:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
40019768:	10 bf ff e9 	b  4001970c <msdos_eval_token+0x50>            
4001976c:	c2 27 60 28 	st  %g1, [ %i5 + 0x28 ]                        
                                                                      

4001d064 <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) {
4001d064:	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;     
4001d068:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001d06c:	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;     
4001d070:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001d074:	94 10 20 00 	clr  %o2                                       
4001d078:	7f ff b5 60 	call  4000a5f8 <rtems_semaphore_obtain>        
4001d07c:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001d080:	80 a2 20 00 	cmp  %o0, 0                                    
4001d084:	12 80 00 09 	bne  4001d0a8 <msdos_file_close+0x44>          <== NEVER TAKEN
4001d088:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    rc = msdos_file_update(iop);                                      
4001d08c:	7f ff ff df 	call  4001d008 <msdos_file_update>             
4001d090:	90 10 00 18 	mov  %i0, %o0                                  
4001d094:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001d098:	7f ff b5 a7 	call  4000a734 <rtems_semaphore_release>       
4001d09c:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    return rc;                                                        
}                                                                     
4001d0a0:	81 c7 e0 08 	ret                                            
4001d0a4:	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);                    
4001d0a8:	40 00 01 3a 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001d0ac:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001d0b0:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001d0b4:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001d0b8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d0bc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001d2c8 <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) {
4001d2c8:	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;     
4001d2cc:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
4001d2d0:	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;     
4001d2d4:	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,        
4001d2d8:	92 10 20 00 	clr  %o1                                       
4001d2dc:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
4001d2e0:	7f ff b4 c6 	call  4000a5f8 <rtems_semaphore_obtain>        
4001d2e4:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001d2e8:	80 a2 20 00 	cmp  %o0, 0                                    
4001d2ec:	12 80 00 31 	bne  4001d3b0 <msdos_file_ftruncate+0xe8>      <== NEVER TAKEN
4001d2f0:	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) {                                        
4001d2f4:	14 80 00 1f 	bg  4001d370 <msdos_file_ftruncate+0xa8>       <== NEVER TAKEN
4001d2f8:	f6 07 20 18 	ld  [ %i4 + 0x18 ], %i3                        
4001d2fc:	80 a2 00 19 	cmp  %o0, %i1                                  
4001d300:	12 80 00 06 	bne  4001d318 <msdos_file_ftruncate+0x50>      <== NEVER TAKEN
4001d304:	90 10 00 1d 	mov  %i5, %o0                                  
4001d308:	80 a6 c0 1a 	cmp  %i3, %i2                                  
4001d30c:	18 80 00 1b 	bgu  4001d378 <msdos_file_ftruncate+0xb0>      
4001d310:	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,                           
4001d314:	90 10 00 1d 	mov  %i5, %o0                                  
4001d318:	92 10 00 1c 	mov  %i4, %o1                                  
4001d31c:	94 10 20 01 	mov  1, %o2                                    
4001d320:	96 10 00 1a 	mov  %i2, %o3                                  
4001d324:	7f ff da be 	call  40013e1c <fat_file_extend>               
4001d328:	98 07 bf fc 	add  %fp, -4, %o4                              
                             fat_fd,                                  
                             true,                                    
                             length,                                  
                             &new_length);                            
        if (rc == RC_OK && length != new_length) {                    
4001d32c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001d330:	12 80 00 17 	bne  4001d38c <msdos_file_ftruncate+0xc4>      <== NEVER TAKEN
4001d334:	80 a6 00 19 	cmp  %i0, %i1                                  
4001d338:	02 80 00 19 	be  4001d39c <msdos_file_ftruncate+0xd4>       <== ALWAYS TAKEN
4001d33c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
            fat_file_truncate(&fs_info->fat, fat_fd, old_length);     
4001d340:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001d344:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
4001d348:	7f ff da 11 	call  40013b8c <fat_file_truncate>             <== NOT EXECUTED
4001d34c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            errno = ENOSPC;                                           
4001d350:	40 00 00 90 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001d354:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001d358:	82 10 20 1c 	mov  0x1c, %g1                                 <== NOT EXECUTED
4001d35c:	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);                       
4001d360:	7f ff b4 f5 	call  4000a734 <rtems_semaphore_release>       <== NOT EXECUTED
4001d364:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        <== NOT EXECUTED
                                                                      
    return rc;                                                        
}                                                                     
4001d368:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d36c:	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);        
4001d370:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001d374:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001d378:	7f ff da 05 	call  40013b8c <fat_file_truncate>             
4001d37c:	94 10 00 1a 	mov  %i2, %o2                                  
            errno = ENOSPC;                                           
            rc = -1;                                                  
        }                                                             
    }                                                                 
                                                                      
    if (rc == RC_OK) {                                                
4001d380:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001d384:	22 80 00 02 	be,a   4001d38c <msdos_file_ftruncate+0xc4>    <== ALWAYS TAKEN
4001d388:	f4 27 20 18 	st  %i2, [ %i4 + 0x18 ]                        
        fat_fd->fat_file_size = length;                               
    }                                                                 
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001d38c:	7f ff b4 ea 	call  4000a734 <rtems_semaphore_release>       
4001d390:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                                                      
    return rc;                                                        
}                                                                     
4001d394:	81 c7 e0 08 	ret                                            
4001d398:	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) {                    
4001d39c:	80 a0 40 1a 	cmp  %g1, %i2                                  
4001d3a0:	12 bf ff e9 	bne  4001d344 <msdos_file_ftruncate+0x7c>      <== NEVER TAKEN
4001d3a4:	92 10 00 1c 	mov  %i4, %o1                                  
            rc = -1;                                                  
        }                                                             
    }                                                                 
                                                                      
    if (rc == RC_OK) {                                                
        fat_fd->fat_file_size = length;                               
4001d3a8:	10 bf ff f9 	b  4001d38c <msdos_file_ftruncate+0xc4>        
4001d3ac:	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);                    
4001d3b0:	40 00 00 78 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001d3b4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001d3b8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001d3bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001d3c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d3c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001d0c0 <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) {
4001d0c0:	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;     
4001d0c4:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
4001d0c8:	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;     
4001d0cc:	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,        
4001d0d0:	92 10 20 00 	clr  %o1                                       
4001d0d4:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
4001d0d8:	7f ff b5 48 	call  4000a5f8 <rtems_semaphore_obtain>        
4001d0dc:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001d0e0:	80 a2 20 00 	cmp  %o0, 0                                    
4001d0e4:	12 80 00 12 	bne  4001d12c <msdos_file_read+0x6c>           <== NEVER TAKEN
4001d0e8:	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,    
4001d0ec:	d4 06 20 0c 	ld  [ %i0 + 0xc ], %o2                         
4001d0f0:	90 10 00 10 	mov  %l0, %o0                                  
4001d0f4:	92 10 00 1d 	mov  %i5, %o1                                  
4001d0f8:	7f ff da 20 	call  40013978 <fat_file_read>                 
4001d0fc:	96 10 00 1a 	mov  %i2, %o3                                  
                        buffer);                                      
    if (ret > 0)                                                      
4001d100:	b2 92 20 00 	orcc  %o0, 0, %i1                              
4001d104:	04 80 00 06 	ble  4001d11c <msdos_file_read+0x5c>           
4001d108:	85 3e 60 1f 	sra  %i1, 0x1f, %g2                            
        iop->offset += ret;                                           
4001d10c:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
4001d110:	b6 87 40 19 	addcc  %i5, %i1, %i3                           
4001d114:	b4 47 00 02 	addx  %i4, %g2, %i2                            
4001d118:	f4 3e 20 08 	std  %i2, [ %i0 + 8 ]                          
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001d11c:	7f ff b5 86 	call  4000a734 <rtems_semaphore_release>       
4001d120:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
    return ret;                                                       
}                                                                     
4001d124:	81 c7 e0 08 	ret                                            
4001d128:	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);                    
4001d12c:	40 00 01 19 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001d130:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
4001d134:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001d138:	10 bf ff fb 	b  4001d124 <msdos_file_read+0x64>             <== NOT EXECUTED
4001d13c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      

4001d218 <msdos_file_stat>: int msdos_file_stat( const rtems_filesystem_location_info_t *loc, struct stat *buf ) {
4001d218:	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;              
4001d21c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    fat_file_fd_t     *fat_fd = loc->node_access;                     
4001d220:	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;              
4001d224:	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,        
4001d228:	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;            
4001d22c:	f6 17 60 06 	lduh  [ %i5 + 6 ], %i3                         
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001d230:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
4001d234:	94 10 20 00 	clr  %o2                                       
4001d238:	7f ff b4 f0 	call  4000a5f8 <rtems_semaphore_obtain>        
4001d23c:	b6 06 ff ff 	add  %i3, -1, %i3                              
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001d240:	80 a2 20 00 	cmp  %o0, 0                                    
4001d244:	12 80 00 1b 	bne  4001d2b0 <msdos_file_stat+0x98>           <== NEVER TAKEN
4001d248:	01 00 00 00 	nop                                            
4001d24c:	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;                                        
4001d250:	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);
4001d254:	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;                           
4001d258:	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;                             
4001d25c:	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;                                    
4001d260:	c8 07 20 40 	ld  [ %i4 + 0x40 ], %g4                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001d264:	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);
4001d268:	c4 3e 40 00 	std  %g2, [ %i1 ]                              
    buf->st_ino = fat_fd->ino;                                        
    buf->st_mode  = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;            
4001d26c:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
4001d270:	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)   
4001d274:	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;                                        
4001d278:	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)   
4001d27c:	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;                                               
4001d280:	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;                                          
4001d284:	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;                                               
4001d288:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
    buf->st_size = fat_fd->fat_file_size;                             
4001d28c:	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;            
4001d290:	c4 26 60 0c 	st  %g2, [ %i1 + 0xc ]                         
    buf->st_rdev = 0ll;                                               
    buf->st_size = fat_fd->fat_file_size;                             
4001d294:	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;                           
4001d298:	f4 3e 60 40 	std  %i2, [ %i1 + 0x40 ]                       
    buf->st_mtime = fat_fd->mtime;                                    
4001d29c:	c8 26 60 30 	st  %g4, [ %i1 + 0x30 ]                        
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001d2a0:	7f ff b5 25 	call  4000a734 <rtems_semaphore_release>       
4001d2a4:	b0 10 20 00 	clr  %i0                                       
    return RC_OK;                                                     
}                                                                     
4001d2a8:	81 c7 e0 08 	ret                                            
4001d2ac:	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);                    
4001d2b0:	40 00 00 b8 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001d2b4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001d2b8:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001d2bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001d2c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d2c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001d3c8 <msdos_file_sync>: * RETURNS: * RC_OK on success, or -1 if error occured (errno set appropriately) */ int msdos_file_sync(rtems_libio_t *iop) {
4001d3c8:	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;     
4001d3cc:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001d3d0:	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;     
4001d3d4:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001d3d8:	94 10 20 00 	clr  %o2                                       
4001d3dc:	7f ff b4 87 	call  4000a5f8 <rtems_semaphore_obtain>        
4001d3e0:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001d3e4:	80 a2 20 00 	cmp  %o0, 0                                    
4001d3e8:	12 80 00 0d 	bne  4001d41c <msdos_file_sync+0x54>           <== NEVER TAKEN
4001d3ec:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    rc = msdos_file_update(iop);                                      
4001d3f0:	7f ff ff 06 	call  4001d008 <msdos_file_update>             
4001d3f4:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc != RC_OK)                                                  
4001d3f8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001d3fc:	12 80 00 04 	bne  4001d40c <msdos_file_sync+0x44>           <== NEVER TAKEN
4001d400:	01 00 00 00 	nop                                            
    {                                                                 
        rtems_semaphore_release(fs_info->vol_sema);                   
        return rc;                                                    
    }                                                                 
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
4001d404:	7f ff df c8 	call  40015324 <fat_sync>                      
4001d408:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001d40c:	7f ff b4 ca 	call  4000a734 <rtems_semaphore_release>       
4001d410:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    return RC_OK;                                                     
}                                                                     
4001d414:	81 c7 e0 08 	ret                                            
4001d418:	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);                    
4001d41c:	40 00 00 5d 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001d420:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001d424:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001d428:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001d42c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d430:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001d008 <msdos_file_update>: #include "msdos.h" static int msdos_file_update(rtems_libio_t *iop) {
4001d008:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int              rc = RC_OK;                                      
    fat_file_fd_t   *fat_fd = iop->pathinfo.node_access;              
4001d00c:	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))                                 
4001d010:	c2 0e 60 30 	ldub  [ %i1 + 0x30 ], %g1                      
4001d014:	80 88 60 01 	btst  1, %g1                                   
4001d018:	02 80 00 04 	be  4001d028 <msdos_file_update+0x20>          <== ALWAYS TAKEN
4001d01c:	90 10 20 00 	clr  %o0                                       
            return rc;                                                
        }                                                             
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
4001d020:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d024:	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);
4001d028:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
4001d02c:	7f ff f2 bf 	call  40019b28 <msdos_set_first_cluster_num>   
4001d030:	92 10 00 19 	mov  %i1, %o1                                  
        if (rc != RC_OK)                                              
4001d034:	80 a2 20 00 	cmp  %o0, 0                                    
4001d038:	12 bf ff fa 	bne  4001d020 <msdos_file_update+0x18>         <== NEVER TAKEN
4001d03c:	01 00 00 00 	nop                                            
        {                                                             
            return rc;                                                
        }                                                             
                                                                      
        rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);     
4001d040:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
4001d044:	7f ff f2 f4 	call  40019c14 <msdos_set_file_size>           
4001d048:	92 10 00 19 	mov  %i1, %o1                                  
        if (rc != RC_OK)                                              
4001d04c:	80 a2 20 00 	cmp  %o0, 0                                    
4001d050:	12 bf ff f4 	bne  4001d020 <msdos_file_update+0x18>         <== NEVER TAKEN
4001d054:	01 00 00 00 	nop                                            
        {                                                             
            return rc;                                                
        }                                                             
                                                                      
        rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
4001d058:	f0 06 20 28 	ld  [ %i0 + 0x28 ], %i0                        
4001d05c:	7f ff f2 6e 	call  40019a14 <msdos_set_dir_wrt_time_and_date>
4001d060:	81 e8 00 00 	restore                                        
                                                                      

4001d140 <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) {
4001d140:	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;     
4001d144:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
    fat_file_fd_t     *fat_fd = iop->pathinfo.node_access;            
4001d148:	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;     
4001d14c:	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,        
4001d150:	92 10 20 00 	clr  %o1                                       
4001d154:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
4001d158:	7f ff b5 28 	call  4000a5f8 <rtems_semaphore_obtain>        
4001d15c:	94 10 20 00 	clr  %o2                                       
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001d160:	80 a2 20 00 	cmp  %o0, 0                                    
4001d164:	12 80 00 24 	bne  4001d1f4 <msdos_file_write+0xb4>          <== NEVER TAKEN
4001d168:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)                       
4001d16c:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4001d170:	80 88 62 00 	btst  0x200, %g1                               
4001d174:	32 80 00 1b 	bne,a   4001d1e0 <msdos_file_write+0xa0>       
4001d178:	d4 04 60 18 	ld  [ %l1 + 0x18 ], %o2                        
4001d17c:	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,   
4001d180:	98 10 00 19 	mov  %i1, %o4                                  
4001d184:	90 10 00 10 	mov  %l0, %o0                                  
4001d188:	92 10 00 11 	mov  %l1, %o1                                  
4001d18c:	7f ff db b9 	call  40014070 <fat_file_write>                
4001d190:	96 10 00 1a 	mov  %i2, %o3                                  
                         buffer);                                     
    if (ret < 0)                                                      
4001d194:	b2 92 20 00 	orcc  %o0, 0, %i1                              
4001d198:	06 80 00 1c 	bl  4001d208 <msdos_file_write+0xc8>           <== NEVER TAKEN
4001d19c:	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;                                               
4001d1a0:	f4 1e 20 08 	ldd  [ %i0 + 8 ], %i2                          
4001d1a4:	86 86 40 1b 	addcc  %i1, %i3, %g3                           
4001d1a8:	84 47 00 1a 	addx  %i4, %i2, %g2                            
4001d1ac:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
    if (iop->offset > fat_fd->fat_file_size)                          
4001d1b0:	80 a0 a0 00 	cmp  %g2, 0                                    
4001d1b4:	14 80 00 0e 	bg  4001d1ec <msdos_file_write+0xac>           <== NEVER TAKEN
4001d1b8:	c2 04 60 18 	ld  [ %l1 + 0x18 ], %g1                        
4001d1bc:	80 a0 a0 00 	cmp  %g2, 0                                    
4001d1c0:	12 80 00 04 	bne  4001d1d0 <msdos_file_write+0x90>          <== NEVER TAKEN
4001d1c4:	80 a0 c0 01 	cmp  %g3, %g1                                  
4001d1c8:	38 80 00 02 	bgu,a   4001d1d0 <msdos_file_write+0x90>       
4001d1cc:	c6 24 60 18 	st  %g3, [ %l1 + 0x18 ]                        
        fat_fd->fat_file_size = iop->offset;                          
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001d1d0:	7f ff b5 59 	call  4000a734 <rtems_semaphore_release>       
4001d1d4:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        
    return ret;                                                       
}                                                                     
4001d1d8:	81 c7 e0 08 	ret                                            
4001d1dc:	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;                          
4001d1e0:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
4001d1e4:	10 bf ff e7 	b  4001d180 <msdos_file_write+0x40>            
4001d1e8:	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;                          
4001d1ec:	10 bf ff f9 	b  4001d1d0 <msdos_file_write+0x90>            <== NOT EXECUTED
4001d1f0:	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);                    
4001d1f4:	40 00 00 e7 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001d1f8:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
4001d1fc:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001d200:	10 bf ff f6 	b  4001d1d8 <msdos_file_write+0x98>            <== NOT EXECUTED
4001d204:	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);                   
4001d208:	d0 04 20 9c 	ld  [ %l0 + 0x9c ], %o0                        <== NOT EXECUTED
4001d20c:	7f ff b5 4a 	call  4000a734 <rtems_semaphore_release>       <== NOT EXECUTED
4001d210:	b2 10 3f ff 	mov  -1, %i1                                   <== NOT EXECUTED
        return -1;                                                    
4001d214:	30 bf ff f1 	b,a   4001d1d8 <msdos_file_write+0x98>         <== NOT EXECUTED
                                                                      

4001c7f8 <msdos_filename_unix2dos>: /* * Fill the dos filename string with blanks. These are DOS's pad * characters. */ for (i = 0; i <= 10; i++)
4001c7f8:	82 10 20 00 	clr  %g1                                       
		dn[i] = ' ';                                                        
4001c7fc:	84 10 20 20 	mov  0x20, %g2                                 
4001c800:	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++)                                            
4001c804:	82 00 60 01 	inc  %g1                                       
4001c808:	80 a0 60 0b 	cmp  %g1, 0xb                                  
4001c80c:	32 bf ff fe 	bne,a   4001c804 <msdos_filename_unix2dos+0xc> 
4001c810:	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) {                                    
4001c814:	c2 4a 00 00 	ldsb  [ %o0 ], %g1                             
4001c818:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4001c81c:	02 80 00 5f 	be  4001c998 <msdos_filename_unix2dos+0x1a0>   <== NEVER TAKEN
4001c820:	c4 0a 00 00 	ldub  [ %o0 ], %g2                             
	}                                                                    
                                                                      
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
4001c824:	80 a2 60 00 	cmp  %o1, 0                                    
4001c828:	02 80 00 5a 	be  4001c990 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001c82c:	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++) {         
4001c830:	82 88 a0 ff 	andcc  %g2, 0xff, %g1                          
4001c834:	02 80 00 57 	be  4001c990 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001c838:	09 10 00 b9 	sethi  %hi(0x4002e400), %g4                    
    if (msdos_map[c] == 0)                                            
4001c83c:	88 11 20 18 	or  %g4, 0x18, %g4	! 4002e418 <msdos_map>      
4001c840:	c4 09 00 01 	ldub  [ %g4 + %g1 ], %g2                       
4001c844:	80 88 a0 ff 	btst  0xff, %g2                                
4001c848:	02 80 00 22 	be  4001c8d0 <msdos_filename_unix2dos+0xd8>    
4001c84c:	86 10 00 08 	mov  %o0, %g3                                  
4001c850:	10 80 00 0f 	b  4001c88c <msdos_filename_unix2dos+0x94>     
4001c854:	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++) {         
4001c858:	02 80 00 18 	be  4001c8b8 <msdos_filename_unix2dos+0xc0>    
4001c85c:	01 00 00 00 	nop                                            
4001c860:	c4 08 c0 00 	ldub  [ %g3 ], %g2                             
4001c864:	80 a0 a0 00 	cmp  %g2, 0                                    
4001c868:	02 80 00 16 	be  4001c8c0 <msdos_filename_unix2dos+0xc8>    <== NEVER TAKEN
4001c86c:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001c870:	22 80 00 15 	be,a   4001c8c4 <msdos_filename_unix2dos+0xcc> 
4001c874:	c2 0a 20 01 	ldub  [ %o0 + 1 ], %g1                         
    if (msdos_map[c] == 0)                                            
4001c878:	c4 09 00 02 	ldub  [ %g4 + %g2 ], %g2                       
4001c87c:	80 88 a0 ff 	btst  0xff, %g2                                
4001c880:	22 80 00 11 	be,a   4001c8c4 <msdos_filename_unix2dos+0xcc> 
4001c884:	c2 0a 20 01 	ldub  [ %o0 + 1 ], %g1                         
      break;                                                          
		dn[i] = msdos_map[c];                                               
		un++;                                                               
4001c888:	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];                                               
4001c88c:	c4 2a 80 01 	stb  %g2, [ %o2 + %g1 ]                        
		un++;                                                               
4001c890:	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++) {         
4001c894:	82 00 60 01 	inc  %g1                                       
4001c898:	84 10 20 01 	mov  1, %g2                                    
4001c89c:	80 a0 60 07 	cmp  %g1, 7                                    
4001c8a0:	04 80 00 03 	ble  4001c8ac <msdos_filename_unix2dos+0xb4>   
4001c8a4:	92 02 7f ff 	add  %o1, -1, %o1                              
4001c8a8:	84 10 20 00 	clr  %g2                                       
4001c8ac:	80 88 a0 ff 	btst  0xff, %g2                                
4001c8b0:	12 bf ff ea 	bne  4001c858 <msdos_filename_unix2dos+0x60>   
4001c8b4:	80 a2 60 00 	cmp  %o1, 0                                    
                                                                      
	/*                                                                   
	 * Strip any further characters up to a '.' or the end of the        
	 * string.                                                           
	 */                                                                  
	while (unlen && (c = *un)) {                                         
4001c8b8:	02 80 00 36 	be  4001c990 <msdos_filename_unix2dos+0x198>   
4001c8bc:	01 00 00 00 	nop                                            
4001c8c0:	c2 0a 20 01 	ldub  [ %o0 + 1 ], %g1                         
4001c8c4:	80 a0 60 00 	cmp  %g1, 0                                    
4001c8c8:	02 80 00 32 	be  4001c990 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001c8cc:	01 00 00 00 	nop                                            
		un++;                                                               
4001c8d0:	86 00 e0 01 	inc  %g3                                       
		unlen--;                                                            
		/* Make sure we've skipped over the dot before stopping. */         
		if (c == '.')                                                       
4001c8d4:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4001c8d8:	02 80 00 0c 	be  4001c908 <msdos_filename_unix2dos+0x110>   
4001c8dc:	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)) {                                         
4001c8e0:	80 a2 60 00 	cmp  %o1, 0                                    
4001c8e4:	02 80 00 2b 	be  4001c990 <msdos_filename_unix2dos+0x198>   
4001c8e8:	01 00 00 00 	nop                                            
4001c8ec:	c2 08 c0 00 	ldub  [ %g3 ], %g1                             
4001c8f0:	80 a0 60 00 	cmp  %g1, 0                                    
4001c8f4:	02 80 00 27 	be  4001c990 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001c8f8:	92 02 7f ff 	add  %o1, -1, %o1                              
		un++;                                                               
		unlen--;                                                            
		/* Make sure we've skipped over the dot before stopping. */         
		if (c == '.')                                                       
4001c8fc:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4001c900:	12 bf ff f8 	bne  4001c8e0 <msdos_filename_unix2dos+0xe8>   <== ALWAYS TAKEN
4001c904:	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++) {                    
4001c908:	80 a2 60 00 	cmp  %o1, 0                                    
4001c90c:	02 80 00 21 	be  4001c990 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001c910:	01 00 00 00 	nop                                            
4001c914:	c2 08 c0 00 	ldub  [ %g3 ], %g1                             
4001c918:	80 a0 60 00 	cmp  %g1, 0                                    
4001c91c:	02 80 00 1d 	be  4001c990 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001c920:	01 00 00 00 	nop                                            
    if (msdos_map[c] == 0)                                            
4001c924:	c4 09 00 01 	ldub  [ %g4 + %g1 ], %g2                       
4001c928:	80 88 a0 ff 	btst  0xff, %g2                                
4001c92c:	02 80 00 19 	be  4001c990 <msdos_filename_unix2dos+0x198>   
4001c930:	82 10 20 08 	mov  8, %g1                                    
      break;                                                          
    dn[i] = msdos_map[c];                                             
4001c934:	10 80 00 0d 	b  4001c968 <msdos_filename_unix2dos+0x170>    
4001c938:	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++) {                    
4001c93c:	02 80 00 15 	be  4001c990 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001c940:	01 00 00 00 	nop                                            
4001c944:	c4 0b 7f f8 	ldub  [ %o5 + -8 ], %g2                        
4001c948:	80 a0 a0 00 	cmp  %g2, 0                                    
4001c94c:	02 80 00 11 	be  4001c990 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001c950:	01 00 00 00 	nop                                            
    if (msdos_map[c] == 0)                                            
4001c954:	c4 09 00 02 	ldub  [ %g4 + %g2 ], %g2                       
4001c958:	80 88 a0 ff 	btst  0xff, %g2                                
4001c95c:	02 80 00 0d 	be  4001c990 <msdos_filename_unix2dos+0x198>   <== NEVER TAKEN
4001c960:	01 00 00 00 	nop                                            
      break;                                                          
    dn[i] = msdos_map[c];                                             
4001c964:	c4 2a 80 01 	stb  %g2, [ %o2 + %g1 ]                        
		un++;                                                               
		unlen--;                                                            
4001c968:	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++) {                    
4001c96c:	82 00 60 01 	inc  %g1                                       
4001c970:	84 10 20 01 	mov  1, %g2                                    
4001c974:	80 a0 60 0a 	cmp  %g1, 0xa                                  
4001c978:	04 80 00 03 	ble  4001c984 <msdos_filename_unix2dos+0x18c>  
4001c97c:	9a 00 c0 01 	add  %g3, %g1, %o5                             
4001c980:	84 10 20 00 	clr  %g2                                       
4001c984:	80 88 a0 ff 	btst  0xff, %g2                                
4001c988:	12 bf ff ed 	bne  4001c93c <msdos_filename_unix2dos+0x144>  
4001c98c:	80 a2 60 00 	cmp  %o1, 0                                    
    dn[i] = msdos_map[c];                                             
		un++;                                                               
		unlen--;                                                            
	}                                                                    
	return 0;                                                            
}                                                                     
4001c990:	81 c3 e0 08 	retl                                           
4001c994:	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) {                                    
4001c998:	80 a2 60 01 	cmp  %o1, 1                                    <== NOT EXECUTED
4001c99c:	22 bf ff fd 	be,a   4001c990 <msdos_filename_unix2dos+0x198><== NOT EXECUTED
4001c9a0:	c2 2a 80 00 	stb  %g1, [ %o2 ]                              <== NOT EXECUTED
		dn[0] = '.';                                                        
		return 0;                                                           
	}                                                                    
	if (un[0] == '.' && un[1] == '.' && unlen == 2) {                    
4001c9a4:	c2 4a 20 01 	ldsb  [ %o0 + 1 ], %g1                         <== NOT EXECUTED
4001c9a8:	80 a0 60 2e 	cmp  %g1, 0x2e                                 <== NOT EXECUTED
4001c9ac:	12 80 00 05 	bne  4001c9c0 <msdos_filename_unix2dos+0x1c8>  <== NOT EXECUTED
4001c9b0:	80 a2 60 00 	cmp  %o1, 0                                    <== NOT EXECUTED
4001c9b4:	80 a2 60 02 	cmp  %o1, 2                                    <== NOT EXECUTED
4001c9b8:	02 80 00 0e 	be  4001c9f0 <msdos_filename_unix2dos+0x1f8>   <== NOT EXECUTED
4001c9bc:	80 a2 60 00 	cmp  %o1, 0                                    <== NOT EXECUTED
	}                                                                    
                                                                      
  /*                                                                  
   * Remove any dots from the start of a file name.                   
   */                                                                 
	while (unlen && (*un == '.')) {                                      
4001c9c0:	32 80 00 08 	bne,a   4001c9e0 <msdos_filename_unix2dos+0x1e8><== NOT EXECUTED
4001c9c4:	92 82 7f ff 	addcc  %o1, -1, %o1                            <== NOT EXECUTED
4001c9c8:	30 bf ff f2 	b,a   4001c990 <msdos_filename_unix2dos+0x198> <== NOT EXECUTED
4001c9cc:	c2 4a 00 00 	ldsb  [ %o0 ], %g1                             <== NOT EXECUTED
4001c9d0:	80 a0 60 2e 	cmp  %g1, 0x2e                                 <== NOT EXECUTED
4001c9d4:	12 bf ff 97 	bne  4001c830 <msdos_filename_unix2dos+0x38>   <== NOT EXECUTED
4001c9d8:	c4 0a 00 00 	ldub  [ %o0 ], %g2                             <== NOT EXECUTED
4001c9dc:	92 82 7f ff 	addcc  %o1, -1, %o1                            <== NOT EXECUTED
4001c9e0:	12 bf ff fb 	bne  4001c9cc <msdos_filename_unix2dos+0x1d4>  <== NOT EXECUTED
4001c9e4:	90 02 20 01 	inc  %o0                                       <== NOT EXECUTED
    dn[i] = msdos_map[c];                                             
		un++;                                                               
		unlen--;                                                            
	}                                                                    
	return 0;                                                            
}                                                                     
4001c9e8:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4001c9ec:	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] = '.';                                                        
4001c9f0:	c2 2a 80 00 	stb  %g1, [ %o2 ]                              <== NOT EXECUTED
		dn[1] = '.';                                                        
		return 0;                                                           
4001c9f4:	10 bf ff e7 	b  4001c990 <msdos_filename_unix2dos+0x198>    <== NOT EXECUTED
4001c9f8:	c2 2a a0 01 	stb  %g1, [ %o2 + 1 ]                          <== NOT EXECUTED
                                                                      

4001af8c <msdos_find_name>: msdos_find_name( rtems_filesystem_location_info_t *parent_loc, const char *name, int name_len ) {
4001af8c:	9d e3 bf 60 	save  %sp, -160, %sp                           
    int                rc = RC_OK;                                    
    msdos_fs_info_t   *fs_info = parent_loc->mt_entry->fs_info;       
4001af90:	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);         
4001af94:	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;       
4001af98:	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,                            
4001af9c:	94 10 00 1d 	mov  %i5, %o2                                  
4001afa0:	92 10 00 1a 	mov  %i2, %o1                                  
4001afa4:	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;                                 
4001afa8:	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);         
4001afac:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
4001afb0:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
4001afb4:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
4001afb8:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
4001afbc:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
4001afc0:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
4001afc4:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
4001afc8:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
    name_type = msdos_long_to_short (name,                            
4001afcc:	7f ff fa 04 	call  400197dc <msdos_long_to_short>           
4001afd0:	90 10 00 19 	mov  %i1, %o0                                  
msdos_find_name(                                                      
    rtems_filesystem_location_info_t *parent_loc,                     
    const char                       *name,                           
    int                               name_len                        
    )                                                                 
{                                                                     
4001afd4:	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,                            
4001afd8:	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,
4001afdc:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
4001afe0:	90 10 00 18 	mov  %i0, %o0                                  
4001afe4:	92 10 20 00 	clr  %o1                                       
4001afe8:	94 10 00 19 	mov  %i1, %o2                                  
4001afec:	96 10 00 1a 	mov  %i2, %o3                                  
4001aff0:	7f ff ff a6 	call  4001ae88 <msdos_get_name_node>           
4001aff4:	9a 07 bf d0 	add  %fp, -48, %o5                             
                             &dir_pos, node_entry);                   
    if (rc != RC_OK)                                                  
4001aff8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001affc:	12 80 00 23 	bne  4001b088 <msdos_find_name+0xfc>           
4001b000:	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;                              
4001b004:	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) ||     
4001b008:	84 08 60 08 	and  %g1, 8, %g2                               
4001b00c:	80 88 a0 ff 	btst  0xff, %g2                                
4001b010:	12 80 00 1e 	bne  4001b088 <msdos_find_name+0xfc>           <== NEVER TAKEN
4001b014:	b0 16 21 01 	or  %i0, 0x101, %i0                            
4001b018:	82 08 60 3f 	and  %g1, 0x3f, %g1                            
4001b01c:	80 a0 60 0f 	cmp  %g1, 0xf                                  
4001b020:	02 80 00 1a 	be  4001b088 <msdos_find_name+0xfc>            <== NEVER TAKEN
4001b024:	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);             
4001b028:	92 07 bf d0 	add  %fp, -48, %o1                             
4001b02c:	7f ff e1 9f 	call  400136a8 <fat_file_open>                 
4001b030:	94 07 bf cc 	add  %fp, -52, %o2                             
    if (rc != RC_OK)                                                  
4001b034:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001b038:	12 80 00 14 	bne  4001b088 <msdos_find_name+0xfc>           <== NEVER TAKEN
4001b03c:	fa 07 bf cc 	ld  [ %fp + -52 ], %i5                         
        return rc;                                                    
                                                                      
    fat_fd->dir_pos = dir_pos;                                        
4001b040:	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)                                       
4001b044:	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;                                        
4001b048:	c4 27 60 20 	st  %g2, [ %i5 + 0x20 ]                        
4001b04c:	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)                                       
4001b050:	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;                                        
4001b054:	c4 27 60 24 	st  %g2, [ %i5 + 0x24 ]                        
4001b058:	c4 07 bf d8 	ld  [ %fp + -40 ], %g2                         
4001b05c:	c4 27 60 28 	st  %g2, [ %i5 + 0x28 ]                        
4001b060:	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)                                       
4001b064:	02 80 00 0b 	be  4001b090 <msdos_find_name+0x104>           
4001b068:	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);      
4001b06c:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
4001b070:	7f ff e3 08 	call  40013c90 <fat_file_close>                
4001b074:	90 10 00 1b 	mov  %i3, %o0                                  
    if (rc != RC_OK)                                                  
4001b078:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001b07c:	12 80 00 45 	bne  4001b190 <msdos_find_name+0x204>          <== NEVER TAKEN
4001b080:	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;                                 
4001b084:	c2 27 20 08 	st  %g1, [ %i4 + 8 ]                           
                                                                      
    return rc;                                                        
}                                                                     
4001b088:	81 c7 e0 08 	ret                                            
4001b08c:	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));
4001b090:	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);          
4001b094:	c8 17 bf f4 	lduh  [ %fp + -12 ], %g4                       
4001b098:	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));
4001b09c:	c4 17 bf f8 	lduh  [ %fp + -8 ], %g2                        
4001b0a0:	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);          
4001b0a4:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001b0a8:	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));
4001b0ac:	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);          
4001b0b0:	b1 31 20 18 	srl  %g4, 0x18, %i0                            
4001b0b4:	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));
4001b0b8:	91 30 a0 18 	srl  %g2, 0x18, %o0                            
4001b0bc:	93 30 60 18 	srl  %g1, 0x18, %o1                            
4001b0c0:	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);          
4001b0c4:	89 31 20 08 	srl  %g4, 8, %g4                               
4001b0c8:	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));
4001b0cc:	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);          
4001b0d0:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
4001b0d4:	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));
4001b0d8:	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);          
4001b0dc:	88 09 00 01 	and  %g4, %g1, %g4                             
4001b0e0:	86 08 c0 01 	and  %g3, %g1, %g3                             
4001b0e4:	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));
4001b0e8:	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);          
4001b0ec:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001b0f0:	86 16 40 03 	or  %i1, %g3, %g3                              
4001b0f4:	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));
4001b0f8:	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);          
4001b0fc:	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));
4001b100:	40 00 05 70 	call  4001c6c0 <msdos_date_dos2unix>           
4001b104:	90 12 00 02 	or  %o0, %g2, %o0                              
                                                                      
        if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)     
4001b108:	c2 0f bf eb 	ldub  [ %fp + -21 ], %g1                       
4001b10c:	82 08 60 10 	and  %g1, 0x10, %g1                            
4001b110:	80 88 60 ff 	btst  0xff, %g1                                
4001b114:	12 80 00 27 	bne  4001b1b0 <msdos_find_name+0x224>          
4001b118:	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));
4001b11c:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
4001b120:	c2 07 bf cc 	ld  [ %fp + -52 ], %g1                         
4001b124:	bb 28 a0 18 	sll  %g2, 0x18, %i5                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
4001b128:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
4001b12c:	87 30 a0 08 	srl  %g2, 8, %g3                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b130:	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;                                       
4001b134:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b138:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001b13c:	86 11 00 03 	or  %g4, %g3, %g3                              
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
4001b140:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
4001b144:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
4001b148:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001b14c:	84 10 c0 02 	or  %g3, %g2, %g2                              
            fat_fd->fat_file_type = FAT_FILE;                         
4001b150:	86 10 20 04 	mov  4, %g3                                    
                return rc;                                            
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
4001b154:	c4 20 60 18 	st  %g2, [ %g1 + 0x18 ]                        
            fat_fd->fat_file_type = FAT_FILE;                         
4001b158:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
            fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;                 
4001b15c:	86 10 3f ff 	mov  -1, %g3                                   
4001b160:	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;                           
4001b164:	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;                                     
4001b168:	c0 20 60 34 	clr  [ %g1 + 0x34 ]                            
        fat_fd->map.disk_cln = fat_fd->cln;                           
                                                                      
        if ((fat_fd->fat_file_size != 0) &&                           
4001b16c:	80 a0 a0 00 	cmp  %g2, 0                                    
4001b170:	02 80 00 0d 	be  4001b1a4 <msdos_find_name+0x218>           
4001b174:	c6 20 60 38 	st  %g3, [ %g1 + 0x38 ]                        
            (fat_fd->fat_file_size <= fs_info->fat.vol.bpc))          
4001b178:	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) &&                           
4001b17c:	80 a1 00 02 	cmp  %g4, %g2                                  
4001b180:	0a 80 00 0a 	bcs  4001b1a8 <msdos_find_name+0x21c>          
4001b184:	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;                       
4001b188:	10 bf ff b9 	b  4001b06c <msdos_find_name+0xe0>             
4001b18c:	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);                        
4001b190:	d2 07 bf cc 	ld  [ %fp + -52 ], %o1                         <== NOT EXECUTED
4001b194:	7f ff e2 bf 	call  40013c90 <fat_file_close>                <== NOT EXECUTED
4001b198:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001b19c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b1a0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        {                                                             
            fat_fd->map.last_cln = fat_fd->cln;                       
        }                                                             
        else                                                          
        {                                                             
            fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;               
4001b1a4:	84 10 3f ff 	mov  -1, %g2                                   
4001b1a8:	10 bf ff b1 	b  4001b06c <msdos_find_name+0xe0>             
4001b1ac:	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;                    
4001b1b0:	d2 07 bf cc 	ld  [ %fp + -52 ], %o1                         
            fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                
4001b1b4:	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;                    
4001b1b8:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
            fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                
4001b1bc:	c2 22 60 14 	st  %g1, [ %o1 + 0x14 ]                        
                                                                      
            rc = fat_file_size(&fs_info->fat, fat_fd);                
4001b1c0:	7f ff e4 70 	call  40014380 <fat_file_size>                 
4001b1c4:	90 10 00 1b 	mov  %i3, %o0                                  
            if (rc != RC_OK)                                          
4001b1c8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001b1cc:	12 bf ff f1 	bne  4001b190 <msdos_find_name+0x204>          <== NEVER TAKEN
4001b1d0:	c2 07 bf cc 	ld  [ %fp + -52 ], %g1                         
4001b1d4:	10 bf ff e4 	b  4001b164 <msdos_find_name+0x1d8>            
4001b1d8:	c4 00 60 18 	ld  [ %g1 + 0x18 ], %g2                        
                                                                      

40019fbc <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 ) {
40019fbc:	9d e3 bf 80 	save  %sp, -128, %sp                           
40019fc0:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40019fc4:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        
40019fc8:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
40019fcc:	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);                                             
40019fd0:	80 a7 20 00 	cmp  %i4, 0                                    
40019fd4:	04 80 02 80 	ble  4001a9d4 <msdos_find_name_in_fat_file+0xa18><== NEVER TAKEN
40019fd8:	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))               
40019fdc:	c4 07 a0 58 	ld  [ %fp + 0x58 ], %g2                        
40019fe0:	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;                                             
40019fe4:	c4 07 a0 5c 	ld  [ %fp + 0x5c ], %g2                        
40019fe8:	80 a0 00 01 	cmp  %g0, %g1                                  
40019fec:	c0 20 80 00 	clr  [ %g2 ]                                   
  dir_pos->sname.ofs = 0;                                             
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
40019ff0:	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;                                             
40019ff4:	c0 20 a0 04 	clr  [ %g2 + 4 ]                               
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
40019ff8:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
40019ffc:	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;              
4001a000:	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))               
4001a004:	b2 60 3f ff 	subx  %g0, -1, %i1                             
4001a008:	80 a6 60 00 	cmp  %i1, 0                                    
4001a00c:	02 80 00 82 	be  4001a214 <msdos_find_name_in_fat_file+0x258>
4001a010:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
4001a014:	80 a6 a0 00 	cmp  %i2, 0                                    
4001a018:	02 80 00 7f 	be  4001a214 <msdos_find_name_in_fat_file+0x258>
4001a01c:	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) &&                                 
4001a020:	c4 07 a0 48 	ld  [ %fp + 0x48 ], %g2                        
4001a024:	c2 00 a0 20 	ld  [ %g2 + 0x20 ], %g1                        
4001a028:	80 a0 60 01 	cmp  %g1, 1                                    
4001a02c:	22 80 01 85 	be,a   4001a640 <msdos_find_name_in_fat_file+0x684>
4001a030:	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;                                
4001a034:	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))         
4001a038:	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;                                   
4001a03c:	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;                                
4001a040:	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))         
4001a044:	82 00 60 01 	inc  %g1                                       
4001a048:	d8 05 60 a0 	ld  [ %l5 + 0xa0 ], %o4                        
4001a04c:	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),
4001a050:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
4001a054:	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;                       
4001a058:	a6 10 20 00 	clr  %l3                                       
4001a05c:	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;                           
4001a060:	a0 10 20 00 	clr  %l0                                       
4001a064:	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;                           
4001a068:	a4 10 20 00 	clr  %l2                                       
4001a06c:	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;                          
4001a070:	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;                             
4001a074:	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;                                  
4001a078:	a8 10 20 00 	clr  %l4                                       
4001a07c:	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),
4001a080:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
4001a084:	d4 07 bf e8 	ld  [ %fp + -24 ], %o2                         
4001a088:	90 10 00 1c 	mov  %i4, %o0                                  
4001a08c:	7f ff e6 3b 	call  40013978 <fat_file_read>                 
4001a090:	96 10 00 11 	mov  %l1, %o3                                  
4001a094:	80 a2 20 00 	cmp  %o0, 0                                    
4001a098:	02 80 00 e4 	be  4001a428 <msdos_find_name_in_fat_file+0x46c>
4001a09c:	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)                  
4001a0a0:	04 80 01 85 	ble  4001a6b4 <msdos_find_name_in_fat_file+0x6f8><== NEVER TAKEN
4001a0a4:	80 a2 00 11 	cmp  %o0, %l1                                  
            rtems_set_errno_and_return_minus_one(EIO);                
                                                                      
        assert(ret == bts2rd);                                        
4001a0a8:	12 80 02 53 	bne  4001a9f4 <msdos_find_name_in_fat_file+0xa38><== NEVER TAKEN
4001a0ac:	84 10 00 18 	mov  %i0, %g2                                  
4001a0b0:	d8 07 20 a0 	ld  [ %i4 + 0xa0 ], %o4                        
4001a0b4:	b6 10 20 00 	clr  %i3                                       
4001a0b8:	b0 10 00 19 	mov  %i1, %i0                                  
4001a0bc:	ba 10 00 0c 	mov  %o4, %i5                                  
4001a0c0:	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)                               
4001a0c4:	80 a4 20 00 	cmp  %l0, 0                                    
4001a0c8:	12 80 00 04 	bne  4001a0d8 <msdos_find_name_in_fat_file+0x11c>
4001a0cc:	c6 0f 40 00 	ldub  [ %i5 ], %g3                             
4001a0d0:	a4 10 00 1b 	mov  %i3, %l2                                  
4001a0d4:	ae 10 00 14 	mov  %l4, %l7                                  
            {                                                         
                empty_space_entry = dir_entry;                        
                empty_space_offset = dir_offset;                      
            }                                                         
                                                                      
            if (remainder_empty)                                      
4001a0d8:	82 88 e0 ff 	andcc  %g3, 0xff, %g1                          
4001a0dc:	02 80 00 e2 	be  4001a464 <msdos_find_name_in_fat_file+0x4a8>
4001a0e0:	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)                                     
4001a0e4:	02 80 00 69 	be  4001a288 <msdos_find_name_in_fat_file+0x2cc>
4001a0e8:	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)                
4001a0ec:	80 88 60 ff 	btst  0xff, %g1                                
4001a0f0:	02 80 00 07 	be  4001a10c <msdos_find_name_in_fat_file+0x150><== NEVER TAKEN
4001a0f4:	c2 0f 60 0b 	ldub  [ %i5 + 0xb ], %g1                       
4001a0f8:	80 a6 a0 00 	cmp  %i2, 0                                    
4001a0fc:	02 80 00 04 	be  4001a10c <msdos_find_name_in_fat_file+0x150>
4001a100:	01 00 00 00 	nop                                            
                {                                                     
                    empty_space_entry = 0;                            
                    empty_space_count = 0;                            
4001a104:	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;                            
4001a108:	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) == 
4001a10c:	82 08 60 3f 	and  %g1, 0x3f, %g1                            
4001a110:	80 a0 60 0f 	cmp  %g1, 0xf                                  
4001a114:	02 80 00 67 	be  4001a2b0 <msdos_find_name_in_fat_file+0x2f4>
4001a118:	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)                                  
4001a11c:	02 80 00 4a 	be  4001a244 <msdos_find_name_in_fat_file+0x288>
4001a120:	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(                                      
4001a124:	9e 07 60 0a 	add  %i5, 0xa, %o7                             
4001a128:	84 10 00 1d 	mov  %i5, %g2                                  
4001a12c:	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;
4001a130:	10 80 00 09 	b  4001a154 <msdos_find_name_in_fat_file+0x198>
4001a134:	82 10 20 00 	clr  %g1                                       
4001a138:	82 08 60 01 	and  %g1, 1, %g1                               
4001a13c:	c6 08 a0 01 	ldub  [ %g2 + 1 ], %g3                         
4001a140:	80 a0 00 01 	cmp  %g0, %g1                                  
4001a144:	84 00 a0 01 	inc  %g2                                       
4001a148:	82 40 3f ff 	addx  %g0, -1, %g1                             
4001a14c:	82 08 60 80 	and  %g1, 0x80, %g1                            
4001a150:	82 00 7f 80 	add  %g1, -128, %g1                            
4001a154:	88 09 20 ff 	and  %g4, 0xff, %g4                            
4001a158:	89 31 20 01 	srl  %g4, 1, %g4                               
4001a15c:	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++)
4001a160:	80 a0 80 0f 	cmp  %g2, %o7                                  
                            cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
4001a164:	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++)
4001a168:	12 bf ff f4 	bne  4001a138 <msdos_find_name_in_fat_file+0x17c>
4001a16c:	88 10 00 01 	mov  %g1, %g4                                  
                            cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
                                                                      
                        if (lfn_entry || (lfn_checksum != cs))        
4001a170:	88 1d 80 04 	xor  %l6, %g4, %g4                             
4001a174:	80 89 20 ff 	btst  0xff, %g4                                
4001a178:	12 80 00 33 	bne  4001a244 <msdos_find_name_in_fat_file+0x288><== NEVER TAKEN
4001a17c:	80 a5 60 00 	cmp  %l5, 0                                    
4001a180:	80 a6 20 00 	cmp  %i0, 0                                    
4001a184:	12 80 00 30 	bne  4001a244 <msdos_find_name_in_fat_file+0x288><== NEVER TAKEN
4001a188:	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,
4001a18c:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
4001a190:	d6 07 bf e8 	ld  [ %fp + -24 ], %o3                         
4001a194:	d8 07 a0 5c 	ld  [ %fp + 0x5c ], %o4                        
4001a198:	90 10 00 1c 	mov  %i4, %o0                                  
4001a19c:	7f ff e6 eb 	call  40013d48 <fat_file_ioctl>                
4001a1a0:	94 10 20 01 	mov  1, %o2                                    
                                                dir_offset * bts2rd,  
                                                &dir_pos->sname.cln); 
                        if (rc != RC_OK)                              
4001a1a4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001a1a8:	12 80 00 19 	bne  4001a20c <msdos_find_name_in_fat_file+0x250><== NEVER TAKEN
4001a1ac:	c2 07 a0 5c 	ld  [ %fp + 0x5c ], %g1                        
                            return rc;                                
                                                                      
                        dir_pos->sname.ofs = dir_entry;               
                                                                      
                        if (lfn_start.cln != FAT_FILE_SHORT_NAME)     
4001a1b0:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
4001a1b4:	80 a2 7f ff 	cmp  %o1, -1                                   
4001a1b8:	02 80 01 34 	be  4001a688 <msdos_find_name_in_fat_file+0x6cc>
4001a1bc:	f6 20 60 04 	st  %i3, [ %g1 + 4 ]                           
                        {                                             
                          rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
4001a1c0:	7f ff a0 f3 	call  4000258c <.umul>                         
4001a1c4:	90 10 00 11 	mov  %l1, %o0                                  
4001a1c8:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
4001a1cc:	96 10 00 08 	mov  %o0, %o3                                  
4001a1d0:	94 10 20 01 	mov  1, %o2                                    
4001a1d4:	90 10 00 1c 	mov  %i4, %o0                                  
4001a1d8:	7f ff e6 dc 	call  40013d48 <fat_file_ioctl>                
4001a1dc:	98 07 bf f8 	add  %fp, -8, %o4                              
                                              lfn_start.cln * bts2rd, 
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
4001a1e0:	80 a2 20 00 	cmp  %o0, 0                                    
4001a1e4:	12 80 01 27 	bne  4001a680 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
4001a1e8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
4001a1ec:	c4 07 a0 5c 	ld  [ %fp + 0x5c ], %g2                        
                        dir_pos->lname.ofs = lfn_start.ofs;           
                                                                      
                        memcpy(name_dir_entry, entry,                 
4001a1f0:	d0 07 a0 60 	ld  [ %fp + 0x60 ], %o0                        
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
4001a1f4:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
                        dir_pos->lname.ofs = lfn_start.ofs;           
4001a1f8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
                        memcpy(name_dir_entry, entry,                 
4001a1fc:	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;           
4001a200:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
                                                                      
                        memcpy(name_dir_entry, entry,                 
4001a204:	40 00 0f 88 	call  4001e024 <memcpy>                        
4001a208:	94 10 20 20 	mov  0x20, %o2                                 
4001a20c:	81 c7 e0 08 	ret                                            
4001a210:	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 =                                                   
4001a214:	c4 07 a0 54 	ld  [ %fp + 0x54 ], %g2                        
4001a218:	92 10 20 0d 	mov  0xd, %o1                                  
4001a21c:	7f ff a1 18 	call  4000267c <.div>                          
4001a220:	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) &&                                 
4001a224:	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 =                                                   
4001a228:	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) &&                                 
4001a22c:	c2 00 a0 20 	ld  [ %g2 + 0x20 ], %g1                        
4001a230:	80 a0 60 01 	cmp  %g1, 1                                    
4001a234:	32 bf ff 81 	bne,a   4001a038 <msdos_find_name_in_fat_file+0x7c>
4001a238:	e2 15 60 06 	lduh  [ %l5 + 6 ], %l1                         
4001a23c:	10 80 01 01 	b  4001a640 <msdos_find_name_in_fat_file+0x684>
4001a240:	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 ||                                
4001a244:	12 80 00 5f 	bne  4001a3c0 <msdos_find_name_in_fat_file+0x404>
4001a248:	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;              
4001a24c:	82 10 3f ff 	mov  -1, %g1                                   
                    lfn_matched = false;                              
4001a250:	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;              
4001a254:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
4001a258:	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;                                           
4001a25c:	80 a4 40 1b 	cmp  %l1, %i3                                  
4001a260:	18 bf ff 99 	bgu  4001a0c4 <msdos_find_name_in_fat_file+0x108>
4001a264:	ba 07 60 20 	add  %i5, 0x20, %i5                            
4001a268:	98 10 00 19 	mov  %i1, %o4                                  
4001a26c:	b2 10 00 18 	mov  %i0, %i1                                  
4001a270:	b0 10 00 02 	mov  %g2, %i0                                  
4001a274:	c4 07 bf e8 	ld  [ %fp + -24 ], %g2                         
        }                                                             
                                                                      
        if (remainder_empty)                                          
            break;                                                    
                                                                      
        dir_offset++;                                                 
4001a278:	a8 05 20 01 	inc  %l4                                       
4001a27c:	84 00 80 11 	add  %g2, %l1, %g2                             
4001a280:	10 bf ff 80 	b  4001a080 <msdos_find_name_in_fat_file+0xc4> 
4001a284:	c4 27 bf e8 	st  %g2, [ %fp + -24 ]                         
                }                                                     
                break;                                                
            }                                                         
            else if (entry_empty)                                     
            {                                                         
                if (create_node)                                      
4001a288:	80 a6 a0 00 	cmp  %i2, 0                                    
4001a28c:	22 bf ff f4 	be,a   4001a25c <msdos_find_name_in_fat_file+0x2a0>
4001a290:	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))         
4001a294:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
                if (create_node)                                      
                {                                                     
                  /*                                                  
                   * Remainder is not empty so is this entry empty ?  
                   */                                                 
                  empty_space_count++;                                
4001a298:	a0 04 20 01 	inc  %l0                                       
                                                                      
                  if (empty_space_count == (lfn_entries + 1))         
4001a29c:	80 a0 40 10 	cmp  %g1, %l0                                  
4001a2a0:	22 bf ff ee 	be,a   4001a258 <msdos_find_name_in_fat_file+0x29c>
4001a2a4:	a6 10 20 01 	mov  1, %l3                                    
4001a2a8:	10 bf ff ed 	b  4001a25c <msdos_find_name_in_fat_file+0x2a0>
4001a2ac:	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)         
4001a2b0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4001a2b4:	80 a0 7f ff 	cmp  %g1, -1                                   
4001a2b8:	02 80 00 4e 	be  4001a3f0 <msdos_find_name_in_fat_file+0x434>
4001a2bc:	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) & 
4001a2c0:	86 08 e0 3f 	and  %g3, 0x3f, %g3                            
4001a2c4:	80 a0 c0 18 	cmp  %g3, %i0                                  
4001a2c8:	22 80 00 05 	be,a   4001a2dc <msdos_find_name_in_fat_file+0x320><== ALWAYS TAKEN
4001a2cc:	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;          
4001a2d0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
                        continue;                                     
4001a2d4:	10 bf ff e1 	b  4001a258 <msdos_find_name_in_fat_file+0x29c><== NOT EXECUTED
4001a2d8:	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)) ||
4001a2dc:	82 0d a0 ff 	and  %l6, 0xff, %g1                            
4001a2e0:	88 0a a0 ff 	and  %o2, 0xff, %g4                            
4001a2e4:	80 a1 00 01 	cmp  %g4, %g1                                  
4001a2e8:	12 bf ff fb 	bne  4001a2d4 <msdos_find_name_in_fat_file+0x318><== NEVER TAKEN
4001a2ec:	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(                                      
4001a2f0:	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')                               
4001a2f4:	c4 49 00 00 	ldsb  [ %g4 ], %g2                             
#endif                                                                
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
4001a2f8:	b0 06 3f ff 	add  %i0, -1, %i0                              
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
4001a2fc:	83 2e 20 02 	sll  %i0, 2, %g1                               
4001a300:	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(                                      
4001a304:	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;          
4001a308:	9a 23 40 01 	sub  %o5, %g1, %o5                             
4001a30c:	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(                                      
4001a310:	82 10 20 00 	clr  %g1                                       
                        lfn_start.cln = FAT_FILE_SHORT_NAME;          
                        continue;                                     
                    }                                                 
                                                                      
                    lfn_entry--;                                      
                    o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;          
4001a314:	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')                               
4001a318:	80 a0 a0 00 	cmp  %g2, 0                                    
4001a31c:	02 80 00 16 	be  4001a374 <msdos_find_name_in_fat_file+0x3b8><== NEVER TAKEN
4001a320:	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(                                      
4001a324:	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]))
4001a328:	80 a2 c0 0c 	cmp  %o3, %o4                                  
4001a32c:	04 80 00 ce 	ble  4001a664 <msdos_find_name_in_fat_file+0x6a8>
4001a330:	98 02 40 0d 	add  %o1, %o5, %o4                             
4001a334:	d8 4b 00 01 	ldsb  [ %o4 + %g1 ], %o4                       
4001a338:	80 a0 80 0c 	cmp  %g2, %o4                                  
4001a33c:	12 80 00 ca 	bne  4001a664 <msdos_find_name_in_fat_file+0x6a8>
4001a340:	80 a0 60 04 	cmp  %g1, 4                                    
                        {                                             
                            lfn_start.cln = FAT_FILE_SHORT_NAME;      
                            break;                                    
                        }                                             
                                                                      
                        switch (i)                                    
4001a344:	02 80 00 44 	be  4001a454 <msdos_find_name_in_fat_file+0x498>
4001a348:	80 a0 60 0a 	cmp  %g1, 0xa                                  
4001a34c:	02 80 00 3e 	be  4001a444 <msdos_find_name_in_fat_file+0x488>
4001a350:	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++)     
4001a354:	02 80 00 12 	be  4001a39c <msdos_find_name_in_fat_file+0x3e0>
4001a358:	88 01 20 02 	add  %g4, 2, %g4                               
4001a35c:	82 00 60 01 	inc  %g1                                       
4001a360:	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')                               
4001a364:	c4 49 00 00 	ldsb  [ %g4 ], %g2                             
4001a368:	80 a0 a0 00 	cmp  %g2, 0                                    
4001a36c:	12 bf ff ef 	bne  4001a328 <msdos_find_name_in_fat_file+0x36c>
4001a370:	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) &&   
4001a374:	c4 07 bf e4 	ld  [ %fp + -28 ], %g2                         
4001a378:	80 a0 80 03 	cmp  %g2, %g3                                  
4001a37c:	12 80 00 09 	bne  4001a3a0 <msdos_find_name_in_fat_file+0x3e4><== NEVER TAKEN
4001a380:	80 a6 20 00 	cmp  %i0, 0                                    
4001a384:	c4 07 a0 54 	ld  [ %fp + 0x54 ], %g2                        
                                ((o + i) != name_len))                
4001a388:	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) &&   
4001a38c:	80 a0 40 02 	cmp  %g1, %g2                                  
4001a390:	02 80 00 03 	be  4001a39c <msdos_find_name_in_fat_file+0x3e0><== ALWAYS TAKEN
4001a394:	82 10 3f ff 	mov  -1, %g1                                   
                                ((o + i) != name_len))                
                                lfn_start.cln = FAT_FILE_SHORT_NAME;  
4001a398:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          <== NOT EXECUTED
                                p += 2;                               
                                break;                                
                        }                                             
                    }                                                 
                                                                      
                    lfn_matched = ((lfn_entry == 0) &&                
4001a39c:	80 a6 20 00 	cmp  %i0, 0                                    
4001a3a0:	12 80 00 06 	bne  4001a3b8 <msdos_find_name_in_fat_file+0x3fc>
4001a3a4:	84 10 20 00 	clr  %g2                                       
4001a3a8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4001a3ac:	82 38 00 01 	xnor  %g0, %g1, %g1                            
4001a3b0:	80 a0 00 01 	cmp  %g0, %g1                                  
4001a3b4:	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;                          
4001a3b8:	10 bf ff a8 	b  4001a258 <msdos_find_name_in_fat_file+0x29c>
4001a3bc:	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) &&           
4001a3c0:	80 a0 7f ff 	cmp  %g1, -1                                   
4001a3c4:	12 bf ff a3 	bne  4001a250 <msdos_find_name_in_fat_file+0x294><== NEVER TAKEN
4001a3c8:	82 10 3f ff 	mov  -1, %g1                                   
                         (lfn_start.cln == FAT_FILE_SHORT_NAME) &&    
                         (memcmp(MSDOS_DIR_NAME(entry),               
4001a3cc:	d2 07 a0 60 	ld  [ %fp + 0x60 ], %o1                        
4001a3d0:	90 10 00 1d 	mov  %i5, %o0                                  
4001a3d4:	40 00 0e ea 	call  4001df7c <memcmp>                        
4001a3d8:	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) &&    
4001a3dc:	80 a2 20 00 	cmp  %o0, 0                                    
4001a3e0:	12 bf ff 9c 	bne  4001a250 <msdos_find_name_in_fat_file+0x294>
4001a3e4:	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,
4001a3e8:	10 bf ff 6a 	b  4001a190 <msdos_find_name_in_fat_file+0x1d4>
4001a3ec:	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) &           
4001a3f0:	80 88 60 ff 	btst  0xff, %g1                                
4001a3f4:	02 bf ff 99 	be  4001a258 <msdos_find_name_in_fat_file+0x29c>
4001a3f8:	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) &
4001a3fc:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
4001a400:	86 08 e0 3f 	and  %g3, 0x3f, %g3                            
4001a404:	80 a0 c0 01 	cmp  %g3, %g1                                  
4001a408:	32 bf ff 95 	bne,a   4001a25c <msdos_find_name_in_fat_file+0x2a0>
4001a40c:	b6 06 e0 20 	add  %i3, 0x20, %i3                            
                            continue;                                 
                                                                      
                        /*                                            
                         * Get the checksum of the short entry.       
                         */                                           
                        lfn_start.cln = dir_offset;                   
4001a410:	e8 27 bf f8 	st  %l4, [ %fp + -8 ]                          
                        lfn_start.ofs = dir_entry;                    
4001a414:	f6 27 bf fc 	st  %i3, [ %fp + -4 ]                          
                        lfn_entry = lfn_entries;                      
                        lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
4001a418:	b0 10 00 01 	mov  %g1, %i0                                  
4001a41c:	ec 0f 60 0d 	ldub  [ %i5 + 0xd ], %l6                       
4001a420:	10 bf ff a8 	b  4001a2c0 <msdos_find_name_in_fat_file+0x304>
4001a424:	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;                                
4001a428:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        
4001a42c:	aa 10 00 1c 	mov  %i4, %l5                                  
    }                                                                 
                                                                      
    /*                                                                
     * If we are not to create the entry return a not found error.    
     */                                                               
    if (!create_node)                                                 
4001a430:	80 a6 a0 00 	cmp  %i2, 0                                    
4001a434:	12 80 00 16 	bne  4001a48c <msdos_find_name_in_fat_file+0x4d0>
4001a438:	b0 16 21 01 	or  %i0, 0x101, %i0                            
        empty_space_entry = 0;                                        
        read_cluster = true;                                          
    }                                                                 
                                                                      
    return 0;                                                         
}                                                                     
4001a43c:	81 c7 e0 08 	ret                                            
4001a440:	81 e8 00 00 	restore                                        
                        {                                             
                            case 4:                                   
                                p += 5;                               
                                break;                                
                            case 10:                                  
                                p += 4;                               
4001a444:	88 01 20 04 	add  %g4, 4, %g4                               
4001a448:	82 00 60 01 	inc  %g1                                       
4001a44c:	10 bf ff c6 	b  4001a364 <msdos_find_name_in_fat_file+0x3a8>
4001a450:	9e 03 e0 01 	inc  %o7                                       
                        }                                             
                                                                      
                        switch (i)                                    
                        {                                             
                            case 4:                                   
                                p += 5;                               
4001a454:	88 01 20 05 	add  %g4, 5, %g4                               
4001a458:	82 00 60 01 	inc  %g1                                       
4001a45c:	10 bf ff c2 	b  4001a364 <msdos_find_name_in_fat_file+0x3a8>
4001a460:	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)                                     
4001a464:	80 a6 a0 00 	cmp  %i2, 0                                    
4001a468:	02 80 01 1e 	be  4001a8e0 <msdos_find_name_in_fat_file+0x924>
4001a46c:	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)                               
4001a470:	80 8c e0 ff 	btst  0xff, %l3                                
4001a474:	12 80 00 07 	bne  4001a490 <msdos_find_name_in_fat_file+0x4d4>
4001a478:	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;   
4001a47c:	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);
4001a480:	b7 36 e0 05 	srl  %i3, 5, %i3                               
4001a484:	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 +=                                
4001a488:	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)                                 
4001a48c:	c2 07 a0 58 	ld  [ %fp + 0x58 ], %g1                        
4001a490:	80 a0 60 02 	cmp  %g1, 2                                    
4001a494:	02 80 01 1d 	be  4001a908 <msdos_find_name_in_fat_file+0x94c>
4001a498:	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)                                                  
4001a49c:	c4 07 bf e4 	ld  [ %fp + -28 ], %g2                         
4001a4a0:	80 a0 a0 00 	cmp  %g2, 0                                    
4001a4a4:	02 80 00 15 	be  4001a4f8 <msdos_find_name_in_fat_file+0x53c>
4001a4a8:	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(                                      
4001a4ac:	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 =                                            
4001a4b0:	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(                                      
4001a4b4:	88 00 60 0b 	add  %g1, 0xb, %g4                             
4001a4b8:	10 80 00 07 	b  4001a4d4 <msdos_find_name_in_fat_file+0x518>
4001a4bc:	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 =                                            
4001a4c0:	84 08 a0 01 	and  %g2, 1, %g2                               
4001a4c4:	80 a0 00 02 	cmp  %g0, %g2                                  
4001a4c8:	84 40 3f ff 	addx  %g0, -1, %g2                             
4001a4cc:	84 08 a0 80 	and  %g2, 0x80, %g2                            
4001a4d0:	84 00 bf 80 	add  %g2, -128, %g2                            
4001a4d4:	fa 08 c0 00 	ldub  [ %g3 ], %i5                             
4001a4d8:	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++)                                 
4001a4dc:	86 00 e0 01 	inc  %g3                                       
            lfn_checksum =                                            
4001a4e0:	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++)                                 
4001a4e4:	80 a0 c0 04 	cmp  %g3, %g4                                  
            lfn_checksum =                                            
4001a4e8:	82 07 40 01 	add  %i5, %g1, %g1                             
4001a4ec:	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++)                                 
4001a4f0:	12 bf ff f4 	bne  4001a4c0 <msdos_find_name_in_fat_file+0x504>
4001a4f4:	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)                                       
4001a4f8:	80 a4 20 00 	cmp  %l0, 0                                    
4001a4fc:	22 80 00 ba 	be,a   4001a7e4 <msdos_find_name_in_fat_file+0x828>
4001a500:	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;                            
4001a504:	a8 1d 00 17 	xor  %l4, %l7, %l4                             
4001a508:	80 a0 00 14 	cmp  %g0, %l4                                  
4001a50c:	ba 40 20 00 	addx  %g0, 0, %i5                              
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
4001a510:	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;              
4001a514:	84 10 3f ff 	mov  -1, %g2                                   
4001a518:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
4001a51c:	80 a0 60 00 	cmp  %g1, 0                                    
4001a520:	06 80 00 af 	bl  4001a7dc <msdos_find_name_in_fat_file+0x820><== NEVER TAKEN
4001a524:	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))                       
4001a528:	b8 00 60 01 	add  %g1, 1, %i4                               
4001a52c:	90 10 00 17 	mov  %l7, %o0                                  
4001a530:	7f ff a0 17 	call  4000258c <.umul>                         
4001a534:	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,
4001a538:	f2 07 a0 48 	ld  [ %fp + 0x48 ], %i1                        
4001a53c:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    /*                                                                
     * Handle the entry writes.                                       
     */                                                               
    lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;              
    lfn_entry = 0;                                                    
4001a540:	a0 10 20 00 	clr  %l0                                       
4001a544:	b4 10 00 1c 	mov  %i4, %i2                                  
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
    {                                                                 
        int length = 0;                                               
                                                                      
        if (read_cluster)                                             
4001a548:	80 8f 60 ff 	btst  0xff, %i5                                
4001a54c:	32 80 00 b9 	bne,a   4001a830 <msdos_find_name_in_fat_file+0x874>
4001a550:	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;                           
4001a554:	80 a4 40 12 	cmp  %l1, %l2                                  
4001a558:	08 80 00 e9 	bleu  4001a8fc <msdos_find_name_in_fat_file+0x940><== NEVER TAKEN
4001a55c:	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;  
4001a560:	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))                       
4001a564:	80 a7 00 14 	cmp  %i4, %l4                                  
4001a568:	02 80 00 e2 	be  4001a8f0 <msdos_find_name_in_fat_file+0x934>
4001a56c:	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(                                      
4001a570:	c4 07 bf e4 	ld  [ %fp + -28 ], %g2                         
4001a574:	82 38 00 10 	xnor  %g0, %l0, %g1                            
4001a578:	82 00 40 02 	add  %g1, %g2, %g1                             
4001a57c:	85 28 60 02 	sll  %g1, 2, %g2                               
4001a580:	87 28 60 04 	sll  %g1, 4, %g3                               
4001a584:	84 20 c0 02 	sub  %g3, %g2, %g2                             
4001a588:	82 00 80 01 	add  %g2, %g1, %g1                             
4001a58c:	c4 07 a0 50 	ld  [ %fp + 0x50 ], %g2                        
4001a590:	a0 10 00 12 	mov  %l2, %l0                                  
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
4001a594:	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(                                      
4001a598:	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)                 
4001a59c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4001a5a0:	80 a0 7f ff 	cmp  %g1, -1                                   
4001a5a4:	22 80 00 96 	be,a   4001a7fc <msdos_find_name_in_fat_file+0x840>
4001a5a8:	ee 27 bf f8 	st  %l7, [ %fp + -8 ]                          
            }                                                         
                                                                      
            /*                                                        
             * Clear the entry before loading the data.               
             */                                                       
            memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);     
4001a5ac:	94 10 20 20 	mov  0x20, %o2                                 
4001a5b0:	90 10 00 16 	mov  %l6, %o0                                  
4001a5b4:	40 00 0e d9 	call  4001e118 <memset>                        
4001a5b8:	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;
4001a5bc:	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;            
4001a5c0:	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)                                          
4001a5c4:	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;
4001a5c8:	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;                                            
4001a5cc:	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;                                     
4001a5d0:	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(                                      
4001a5d4:	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)                                          
4001a5d8:	80 a3 e0 00 	cmp  %o7, 0                                    
4001a5dc:	02 80 00 11 	be  4001a620 <msdos_find_name_in_fat_file+0x664><== NEVER TAKEN
4001a5e0:	d4 08 c0 00 	ldub  [ %g3 ], %o2                             
                {                                                     
                    *p = *n;                                          
4001a5e4:	d4 28 40 00 	stb  %o2, [ %g1 ]                              
                    p [0] = fill;                                     
                    p [1] = fill;                                     
                    fill = 0xff;                                      
                }                                                     
                                                                      
                switch (i)                                            
4001a5e8:	80 a1 20 04 	cmp  %g4, 4                                    
4001a5ec:	02 80 00 12 	be  4001a634 <msdos_find_name_in_fat_file+0x678>
4001a5f0:	86 00 e0 01 	inc  %g3                                       
4001a5f4:	80 a1 20 0a 	cmp  %g4, 0xa                                  
4001a5f8:	02 80 00 7e 	be  4001a7f0 <msdos_find_name_in_fat_file+0x834>
4001a5fc:	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++)             
4001a600:	02 80 00 33 	be  4001a6cc <msdos_find_name_in_fat_file+0x710>
4001a604:	82 00 60 02 	add  %g1, 2, %g1                               
4001a608:	84 00 a0 01 	inc  %g2                                       
            {                                                         
                if (*n != 0)                                          
4001a60c:	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(                                      
4001a610:	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)                                          
4001a614:	80 a3 e0 00 	cmp  %o7, 0                                    
4001a618:	12 bf ff f3 	bne  4001a5e4 <msdos_find_name_in_fat_file+0x628>
4001a61c:	d4 08 c0 00 	ldub  [ %g3 ], %o2                             
                    *p = *n;                                          
                    n++;                                              
                }                                                     
                else                                                  
                {                                                     
                    p [0] = fill;                                     
4001a620:	d6 28 40 00 	stb  %o3, [ %g1 ]                              
                    p [1] = fill;                                     
4001a624:	d6 28 60 01 	stb  %o3, [ %g1 + 1 ]                          
                    fill = 0xff;                                      
                }                                                     
                                                                      
                switch (i)                                            
4001a628:	80 a1 20 04 	cmp  %g4, 4                                    
4001a62c:	12 bf ff f2 	bne  4001a5f4 <msdos_find_name_in_fat_file+0x638>
4001a630:	96 10 3f ff 	mov  -1, %o3                                   
                {                                                     
                    case 4:                                           
                        p += 5;                                       
4001a634:	82 00 60 05 	add  %g1, 5, %g1                               
4001a638:	10 bf ff f5 	b  4001a60c <msdos_find_name_in_fat_file+0x650>
4001a63c:	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) &&                                 
4001a640:	80 a0 60 00 	cmp  %g1, 0                                    
4001a644:	32 bf fe 7d 	bne,a   4001a038 <msdos_find_name_in_fat_file+0x7c><== NEVER TAKEN
4001a648:	e2 15 60 06 	lduh  [ %l5 + 6 ], %l1                         <== NOT EXECUTED
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
4001a64c:	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) &&                                 
4001a650:	80 88 60 03 	btst  3, %g1                                   
4001a654:	22 bf fe 79 	be,a   4001a038 <msdos_find_name_in_fat_file+0x7c>
4001a658:	e2 15 60 06 	lduh  [ %l5 + 6 ], %l1                         
        (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))            
        bts2rd = fat_fd->fat_file_size;                               
4001a65c:	10 bf fe 77 	b  4001a038 <msdos_find_name_in_fat_file+0x7c> 
4001a660:	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;      
4001a664:	84 10 3f ff 	mov  -1, %g2                                   
4001a668:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
                                p += 2;                               
                                break;                                
                        }                                             
                    }                                                 
                                                                      
                    lfn_matched = ((lfn_entry == 0) &&                
4001a66c:	80 a6 20 00 	cmp  %i0, 0                                    
4001a670:	12 bf ff 52 	bne  4001a3b8 <msdos_find_name_in_fat_file+0x3fc>
4001a674:	84 10 20 00 	clr  %g2                                       
4001a678:	10 bf ff 4d 	b  4001a3ac <msdos_find_name_in_fat_file+0x3f0>
4001a67c:	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)                                    
4001a680:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a684:	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;           
4001a688:	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)     
4001a68c:	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,                 
4001a690:	d0 07 a0 60 	ld  [ %fp + 0x60 ], %o0                        
                                              &lfn_start.cln);        
                          if (rc != RC_OK)                            
                            return rc;                                
                        }                                             
                                                                      
                        dir_pos->lname.cln = lfn_start.cln;           
4001a694:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
                        dir_pos->lname.ofs = lfn_start.ofs;           
4001a698:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
                        memcpy(name_dir_entry, entry,                 
4001a69c:	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;           
4001a6a0:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
                                                                      
                        memcpy(name_dir_entry, entry,                 
4001a6a4:	40 00 0e 60 	call  4001e024 <memcpy>                        
4001a6a8:	94 10 20 20 	mov  0x20, %o2                                 
4001a6ac:	81 c7 e0 08 	ret                                            
4001a6b0:	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);                
4001a6b4:	40 00 0b b7 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001a6b8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001a6bc:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001a6c0:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001a6c4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a6c8:	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(                                      
4001a6cc:	82 26 80 14 	sub  %i2, %l4, %g1                             
                        break;                                        
                }                                                     
            }                                                         
                                                                      
            *MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
            if (lfn_entry == 1)                                       
4001a6d0:	80 a5 20 01 	cmp  %l4, 1                                    
4001a6d4:	02 80 00 4c 	be  4001a804 <msdos_find_name_in_fat_file+0x848>
4001a6d8:	c2 2d 80 00 	stb  %g1, [ %l6 ]                              
                *MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
4001a6dc:	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)          
4001a6e0:	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;                 
4001a6e4:	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;                           
4001a6e8:	80 a4 40 10 	cmp  %l1, %l0                                  
4001a6ec:	08 80 00 4e 	bleu  4001a824 <msdos_find_name_in_fat_file+0x868><== NEVER TAKEN
4001a6f0:	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;  
4001a6f4:	ec 05 60 a0 	ld  [ %l5 + 0xa0 ], %l6                        
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
            lfn_entry++;                                              
4001a6f8:	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;  
4001a6fc:	ac 05 80 10 	add  %l6, %l0, %l6                             
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
4001a700:	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))                       
4001a704:	80 a7 00 14 	cmp  %i4, %l4                                  
4001a708:	12 bf ff a5 	bne  4001a59c <msdos_find_name_in_fat_file+0x5e0>
4001a70c:	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,
4001a710:	d8 07 a0 5c 	ld  [ %fp + 0x5c ], %o4                        
4001a714:	90 10 00 15 	mov  %l5, %o0                                  
4001a718:	92 10 00 19 	mov  %i1, %o1                                  
4001a71c:	94 10 20 01 	mov  1, %o2                                    
4001a720:	7f ff e5 8a 	call  40013d48 <fat_file_ioctl>                
4001a724:	96 10 00 18 	mov  %i0, %o3                                  
                                        empty_space_offset * bts2rd,  
                                        &dir_pos->sname.cln);         
                if (rc != RC_OK)                                      
4001a728:	80 a2 20 00 	cmp  %o0, 0                                    
4001a72c:	12 bf ff d5 	bne  4001a680 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
4001a730:	c4 07 a0 5c 	ld  [ %fp + 0x5c ], %g2                        
                  return rc;                                          
                                                                      
                dir_pos->sname.ofs = dir_entry;                       
                                                                      
                if (lfn_start.cln != FAT_FILE_SHORT_NAME)             
4001a734:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
4001a738:	80 a2 7f ff 	cmp  %o1, -1                                   
4001a73c:	02 80 00 67 	be  4001a8d8 <msdos_find_name_in_fat_file+0x91c>
4001a740:	e0 20 a0 04 	st  %l0, [ %g2 + 4 ]                           
                {                                                     
                  rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
4001a744:	7f ff 9f 92 	call  4000258c <.umul>                         
4001a748:	90 10 00 11 	mov  %l1, %o0                                  
4001a74c:	92 10 00 19 	mov  %i1, %o1                                  
4001a750:	96 10 00 08 	mov  %o0, %o3                                  
4001a754:	94 10 20 01 	mov  1, %o2                                    
4001a758:	90 10 00 15 	mov  %l5, %o0                                  
4001a75c:	7f ff e5 7b 	call  40013d48 <fat_file_ioctl>                
4001a760:	98 07 bf f8 	add  %fp, -8, %o4                              
                                      lfn_start.cln * bts2rd,         
                                      &lfn_start.cln);                
                  if (rc != RC_OK)                                    
4001a764:	80 a2 20 00 	cmp  %o0, 0                                    
4001a768:	12 bf ff c6 	bne  4001a680 <msdos_find_name_in_fat_file+0x6c4><== NEVER TAKEN
4001a76c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
4001a770:	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,            
4001a774:	d2 07 a0 60 	ld  [ %fp + 0x60 ], %o1                        
                                      &lfn_start.cln);                
                  if (rc != RC_OK)                                    
                    return rc;                                        
                }                                                     
                                                                      
                dir_pos->lname.cln = lfn_start.cln;                   
4001a778:	c2 20 a0 08 	st  %g1, [ %g2 + 8 ]                           
                dir_pos->lname.ofs = lfn_start.ofs;                   
4001a77c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
4001a780:	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;                   
4001a784:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
                                                                      
                /* write new node entry */                            
                memcpy (entry, (uint8_t *) name_dir_entry,            
4001a788:	40 00 0e 27 	call  4001e024 <memcpy>                        
4001a78c:	94 10 20 20 	mov  0x20, %o2                                 
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
            lfn_entry++;                                              
4001a790:	a0 10 00 14 	mov  %l4, %l0                                  
4001a794:	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,                   
4001a798:	d8 05 60 a0 	ld  [ %l5 + 0xa0 ], %o4                        
4001a79c:	90 10 00 15 	mov  %l5, %o0                                  
4001a7a0:	92 10 00 19 	mov  %i1, %o1                                  
4001a7a4:	94 06 00 12 	add  %i0, %l2, %o2                             
4001a7a8:	7f ff e6 32 	call  40014070 <fat_file_write>                
4001a7ac:	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)                                                
4001a7b0:	80 a2 3f ff 	cmp  %o0, -1                                   
4001a7b4:	02 80 00 84 	be  4001a9c4 <msdos_find_name_in_fat_file+0xa08><== NEVER TAKEN
4001a7b8:	80 a2 00 1d 	cmp  %o0, %i5                                  
            return ret;                                               
        else if (ret != length)                                       
4001a7bc:	12 bf ff be 	bne  4001a6b4 <msdos_find_name_in_fat_file+0x6f8><== NEVER TAKEN
4001a7c0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
            rtems_set_errno_and_return_minus_one(EIO);                
                                                                      
        empty_space_offset++;                                         
4001a7c4:	ae 05 e0 01 	inc  %l7                                       
4001a7c8:	b0 06 00 11 	add  %i0, %l1, %i0                             
        empty_space_entry = 0;                                        
4001a7cc:	a4 10 20 00 	clr  %l2                                       
#endif                                                                
                                                                      
    /*                                                                
     * The one more is the short entry.                               
     */                                                               
    while (lfn_entry < (lfn_entries + 1))                             
4001a7d0:	80 a0 40 10 	cmp  %g1, %l0                                  
4001a7d4:	16 bf ff 5d 	bge  4001a548 <msdos_find_name_in_fat_file+0x58c><== NEVER TAKEN
4001a7d8:	ba 10 20 01 	mov  1, %i5                                    
        empty_space_offset++;                                         
        empty_space_entry = 0;                                        
        read_cluster = true;                                          
    }                                                                 
                                                                      
    return 0;                                                         
4001a7dc:	81 c7 e0 08 	ret                                            
4001a7e0:	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;                                          
4001a7e4:	ba 10 20 01 	mov  1, %i5                                    
        empty_space_offset = dir_offset;                              
        empty_space_entry = 0;                                        
4001a7e8:	10 bf ff 4a 	b  4001a510 <msdos_find_name_in_fat_file+0x554>
4001a7ec:	a4 10 20 00 	clr  %l2                                       
                {                                                     
                    case 4:                                           
                        p += 5;                                       
                        break;                                        
                    case 10:                                          
                        p += 4;                                       
4001a7f0:	82 00 60 04 	add  %g1, 4, %g1                               
4001a7f4:	10 bf ff 86 	b  4001a60c <msdos_find_name_in_fat_file+0x650>
4001a7f8:	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;                              
4001a7fc:	10 bf ff 6c 	b  4001a5ac <msdos_find_name_in_fat_file+0x5f0>
4001a800:	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;
4001a804:	82 10 60 40 	or  %g1, 0x40, %g1                             
4001a808:	c2 2d 80 00 	stb  %g1, [ %l6 ]                              
            *MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;                 
4001a80c:	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)          
4001a810:	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;                 
4001a814:	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;                           
4001a818:	80 a4 40 10 	cmp  %l1, %l0                                  
4001a81c:	18 bf ff b6 	bgu  4001a6f4 <msdos_find_name_in_fat_file+0x738><== ALWAYS TAKEN
4001a820:	c2 2d a0 0b 	stb  %g1, [ %l6 + 0xb ]                        
4001a824:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
4001a828:	10 bf ff dc 	b  4001a798 <msdos_find_name_in_fat_file+0x7dc><== NOT EXECUTED
4001a82c:	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,                  
4001a830:	90 10 00 15 	mov  %l5, %o0                                  
4001a834:	92 10 00 19 	mov  %i1, %o1                                  
4001a838:	94 10 00 18 	mov  %i0, %o2                                  
4001a83c:	7f ff e4 4f 	call  40013978 <fat_file_read>                 
4001a840:	96 10 00 11 	mov  %l1, %o3                                  
                              (empty_space_offset * bts2rd), bts2rd,  
                              fs_info->cl_buf);                       
                                                                      
          if (ret != bts2rd)                                          
4001a844:	80 a2 00 11 	cmp  %o0, %l1                                  
4001a848:	02 bf ff 43 	be  4001a554 <msdos_find_name_in_fat_file+0x598><== NEVER TAKEN
4001a84c:	80 a2 20 00 	cmp  %o0, 0                                    
          {                                                           
            if (ret != FAT_EOF)                                       
4001a850:	12 80 00 1b 	bne  4001a8bc <msdos_find_name_in_fat_file+0x900><== NEVER TAKEN
4001a854:	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,      
4001a858:	92 10 00 19 	mov  %i1, %o1                                  
4001a85c:	94 10 20 00 	clr  %o2                                       
4001a860:	96 10 00 18 	mov  %i0, %o3                                  
4001a864:	7f ff e5 6e 	call  40013e1c <fat_file_extend>               
4001a868:	98 07 bf f4 	add  %fp, -12, %o4                             
                                   empty_space_offset * bts2rd, &new_length);
                                                                      
            if (ret != RC_OK)                                         
4001a86c:	80 a2 20 00 	cmp  %o0, 0                                    
4001a870:	12 80 00 57 	bne  4001a9cc <msdos_find_name_in_fat_file+0xa10><== NEVER TAKEN
4001a874:	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))          
4001a878:	80 a0 40 18 	cmp  %g1, %i0                                  
4001a87c:	12 80 00 10 	bne  4001a8bc <msdos_find_name_in_fat_file+0x900><== NEVER TAKEN
4001a880:	92 10 20 00 	clr  %o1                                       
              rtems_set_errno_and_return_minus_one(EIO);              
                                                                      
            memset(fs_info->cl_buf, 0, bts2rd);                       
4001a884:	d0 05 60 a0 	ld  [ %l5 + 0xa0 ], %o0                        
4001a888:	40 00 0e 24 	call  4001e118 <memset>                        
4001a88c:	94 10 00 11 	mov  %l1, %o2                                  
                                                                      
            ret = fat_file_write(&fs_info->fat, fat_fd,               
4001a890:	d8 05 60 a0 	ld  [ %l5 + 0xa0 ], %o4                        
4001a894:	90 10 00 15 	mov  %l5, %o0                                  
4001a898:	92 10 00 19 	mov  %i1, %o1                                  
4001a89c:	94 10 00 18 	mov  %i0, %o2                                  
4001a8a0:	7f ff e5 f4 	call  40014070 <fat_file_write>                
4001a8a4:	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)                                            
4001a8a8:	80 a2 3f ff 	cmp  %o0, -1                                   
4001a8ac:	02 80 00 48 	be  4001a9cc <msdos_find_name_in_fat_file+0xa10><== ALWAYS TAKEN
4001a8b0:	80 a2 00 11 	cmp  %o0, %l1                                  
              return ret;                                             
            else if (ret != bts2rd)                                   
4001a8b4:	02 bf ff 29 	be  4001a558 <msdos_find_name_in_fat_file+0x59c><== NOT EXECUTED
4001a8b8:	80 a4 40 12 	cmp  %l1, %l2                                  <== NOT EXECUTED
              rtems_set_errno_and_return_minus_one(EIO);              
4001a8bc:	40 00 0b 35 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001a8c0:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001a8c4:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
4001a8c8:	84 10 3f ff 	mov  -1, %g2                                   <== NOT EXECUTED
4001a8cc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001a8d0:	81 c7 e0 08 	ret                                            
4001a8d4:	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)             
4001a8d8:	10 bf ff a6 	b  4001a770 <msdos_find_name_in_fat_file+0x7b4>
4001a8dc:	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;                  
4001a8e0:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        
4001a8e4:	b0 16 21 01 	or  %i0, 0x101, %i0	! 7d01 <PROM_START+0x7d01> 
4001a8e8:	81 c7 e0 08 	ret                                            
4001a8ec:	81 e8 00 00 	restore                                        
                    length, lfn_entry);                               
#endif                                                                
            /*                                                        
             * Time to write the short file name entry.               
             */                                                       
            if (lfn_entry == (lfn_entries + 1))                       
4001a8f0:	a0 10 00 12 	mov  %l2, %l0                                  
            char*       p;                                            
            const char* n;                                            
            int         i;                                            
            char        fill = 0;                                     
                                                                      
            length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;              
4001a8f4:	10 bf ff 87 	b  4001a710 <msdos_find_name_in_fat_file+0x754>
4001a8f8:	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;                           
4001a8fc:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
4001a900:	10 bf ff a6 	b  4001a798 <msdos_find_name_in_fat_file+0x7dc><== NOT EXECUTED
4001a904:	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) /
4001a908:	7f ff 9f 21 	call  4000258c <.umul>                         
4001a90c:	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 == '.'))                                 
4001a910:	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) /
4001a914:	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 == '.'))                                 
4001a918:	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;
4001a91c:	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) /
4001a920:	bb 32 20 05 	srl  %o0, 5, %i5                               
                         MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
4001a924:	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 == '.'))                                 
4001a928:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001a92c:	02 80 00 05 	be  4001a940 <msdos_find_name_in_fat_file+0x984><== NEVER TAKEN
4001a930:	ba 00 c0 1d 	add  %g3, %i5, %i5                             
4001a934:	80 a0 a0 20 	cmp  %g2, 0x20                                 
4001a938:	12 80 00 06 	bne  4001a950 <msdos_find_name_in_fat_file+0x994>
4001a93c:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
        *c = '_';                                                     
4001a940:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
4001a944:	84 10 20 5f 	mov  0x5f, %g2                                 
4001a948:	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 == '.'))                                 
4001a94c:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
4001a950:	c4 48 60 01 	ldsb  [ %g1 + 1 ], %g2                         
4001a954:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001a958:	02 80 00 06 	be  4001a970 <msdos_find_name_in_fat_file+0x9b4><== NEVER TAKEN
4001a95c:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
4001a960:	80 a0 a0 20 	cmp  %g2, 0x20                                 
4001a964:	12 80 00 06 	bne  4001a97c <msdos_find_name_in_fat_file+0x9c0>
4001a968:	c4 07 a0 60 	ld  [ %fp + 0x60 ], %g2                        
        *c = '_';                                                     
4001a96c:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
4001a970:	84 10 20 5f 	mov  0x5f, %g2                                 
4001a974:	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++)                                      
4001a978:	c4 07 a0 60 	ld  [ %fp + 0x60 ], %g2                        
4001a97c:	09 10 00 b6 	sethi  %hi(0x4002d800), %g4                    
4001a980:	86 00 a0 02 	add  %g2, 2, %g3                               
4001a984:	88 11 22 d0 	or  %g4, 0x2d0, %g4                            
4001a988:	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];                         
4001a98c:	83 3f 40 02 	sra  %i5, %g2, %g1                             
4001a990:	82 08 60 0f 	and  %g1, 0xf, %g1                             
4001a994:	c2 09 00 01 	ldub  [ %g4 + %g1 ], %g1                       
4001a998:	84 00 bf fc 	add  %g2, -4, %g2                              
4001a99c:	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++)                                      
4001a9a0:	80 a0 bf fc 	cmp  %g2, -4                                   
4001a9a4:	12 bf ff fa 	bne  4001a98c <msdos_find_name_in_fat_file+0x9d0>
4001a9a8:	86 00 e0 01 	inc  %g3                                       
      *c = hex[(num >> ((3 - i) * 4)) & 0xf];                         
    *c++ = '~';                                                       
4001a9ac:	c2 07 a0 60 	ld  [ %fp + 0x60 ], %g1                        
4001a9b0:	84 10 20 7e 	mov  0x7e, %g2                                 
4001a9b4:	c4 28 60 06 	stb  %g2, [ %g1 + 6 ]                          
    *c++ = '1';                                                       
4001a9b8:	84 10 20 31 	mov  0x31, %g2                                 
4001a9bc:	10 bf fe b8 	b  4001a49c <msdos_find_name_in_fat_file+0x4e0>
4001a9c0:	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)                                                
4001a9c4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001a9c8:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
4001a9cc:	10 bf ff c1 	b  4001a8d0 <msdos_find_name_in_fat_file+0x914>
4001a9d0:	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);                                             
4001a9d4:	11 10 00 b8 	sethi  %hi(0x4002e000), %o0                    <== NOT EXECUTED
4001a9d8:	15 10 00 b8 	sethi  %hi(0x4002e000), %o2                    <== NOT EXECUTED
4001a9dc:	17 10 00 b8 	sethi  %hi(0x4002e000), %o3                    <== NOT EXECUTED
4001a9e0:	90 12 22 f8 	or  %o0, 0x2f8, %o0                            <== NOT EXECUTED
4001a9e4:	92 10 23 c9 	mov  0x3c9, %o1                                <== NOT EXECUTED
4001a9e8:	94 12 a3 c8 	or  %o2, 0x3c8, %o2                            <== NOT EXECUTED
4001a9ec:	7f ff ac 84 	call  40005bfc <__assert_func>                 <== NOT EXECUTED
4001a9f0:	96 12 e3 88 	or  %o3, 0x388, %o3                            <== NOT EXECUTED
#endif                                                                
                                                                      
        if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)                  
            rtems_set_errno_and_return_minus_one(EIO);                
                                                                      
        assert(ret == bts2rd);                                        
4001a9f4:	11 10 00 b8 	sethi  %hi(0x4002e000), %o0                    <== NOT EXECUTED
4001a9f8:	15 10 00 b8 	sethi  %hi(0x4002e000), %o2                    <== NOT EXECUTED
4001a9fc:	17 10 00 b8 	sethi  %hi(0x4002e000), %o3                    <== NOT EXECUTED
4001aa00:	90 12 22 f8 	or  %o0, 0x2f8, %o0                            <== NOT EXECUTED
4001aa04:	92 10 23 f9 	mov  0x3f9, %o1                                <== NOT EXECUTED
4001aa08:	94 12 a3 c8 	or  %o2, 0x3c8, %o2                            <== NOT EXECUTED
4001aa0c:	7f ff ac 7c 	call  40005bfc <__assert_func>                 <== NOT EXECUTED
4001aa10:	96 12 e3 98 	or  %o3, 0x398, %o3                            <== NOT EXECUTED
                                                                      

4001aa18 <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 ) {
4001aa18:	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) &&                                 
4001aa1c:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
4001aa20:	80 a0 60 01 	cmp  %g1, 1                                    
4001aa24:	02 80 00 36 	be  4001aafc <msdos_find_node_by_cluster_num_in_fat_file+0xe4><== NEVER TAKEN
4001aa28:	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;                                
4001aa2c:	e2 14 a0 06 	lduh  [ %l2 + 6 ], %l1                         
4001aa30:	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)          
4001aa34:	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);                                        
4001aa38:	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)          
4001aa3c:	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,
4001aa40:	90 10 00 12 	mov  %l2, %o0                                  
4001aa44:	92 10 00 19 	mov  %i1, %o1                                  
4001aa48:	94 10 00 13 	mov  %l3, %o2                                  
4001aa4c:	7f ff e3 cb 	call  40013978 <fat_file_read>                 
4001aa50:	96 10 00 11 	mov  %l1, %o3                                  
4001aa54:	80 a2 20 00 	cmp  %o0, 0                                    
4001aa58:	02 80 00 25 	be  4001aaec <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
4001aa5c:	80 a2 20 1f 	cmp  %o0, 0x1f                                 
                                  fs_info->cl_buf)) != FAT_EOF)       
    {                                                                 
        if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )                
4001aa60:	04 80 00 42 	ble  4001ab68 <msdos_find_node_by_cluster_num_in_fat_file+0x150><== NEVER TAKEN
4001aa64:	80 a2 00 11 	cmp  %o0, %l1                                  
            rtems_set_errno_and_return_minus_one( EIO );              
                                                                      
        assert(ret == bts2rd);                                        
4001aa68:	12 80 00 46 	bne  4001ab80 <msdos_find_node_by_cluster_num_in_fat_file+0x168><== NEVER TAKEN
4001aa6c:	a0 10 20 00 	clr  %l0                                       
4001aa70:	d8 04 a0 a0 	ld  [ %l2 + 0xa0 ], %o4                        
4001aa74:	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)) ==                     
4001aa78:	c2 0f 40 00 	ldub  [ %i5 ], %g1                             
4001aa7c:	80 a0 60 00 	cmp  %g1, 0                                    
4001aa80:	02 80 00 1b 	be  4001aaec <msdos_find_node_by_cluster_num_in_fat_file+0xd4><== NEVER TAKEN
4001aa84:	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)) ==                     
4001aa88:	22 80 00 14 	be,a   4001aad8 <msdos_find_node_by_cluster_num_in_fat_file+0xc0><== NEVER TAKEN
4001aa8c:	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)          
4001aa90:	c2 17 60 1a 	lduh  [ %i5 + 0x1a ], %g1                      
4001aa94:	c4 17 60 14 	lduh  [ %i5 + 0x14 ], %g2                      
4001aa98:	83 28 60 10 	sll  %g1, 0x10, %g1                            
4001aa9c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
4001aaa0:	89 30 60 18 	srl  %g1, 0x18, %g4                            
4001aaa4:	9f 30 a0 18 	srl  %g2, 0x18, %o7                            
4001aaa8:	87 30 60 08 	srl  %g1, 8, %g3                               
4001aaac:	85 30 a0 08 	srl  %g2, 8, %g2                               
4001aab0:	86 08 c0 18 	and  %g3, %i0, %g3                             
4001aab4:	84 08 80 18 	and  %g2, %i0, %g2                             
4001aab8:	86 11 00 03 	or  %g4, %g3, %g3                              
4001aabc:	82 13 c0 02 	or  %o7, %g2, %g1                              
4001aac0:	83 28 60 10 	sll  %g1, 0x10, %g1                            
4001aac4:	82 10 40 03 	or  %g1, %g3, %g1                              
4001aac8:	80 a0 40 1a 	cmp  %g1, %i2                                  
4001aacc:	22 80 00 16 	be,a   4001ab24 <msdos_find_node_by_cluster_num_in_fat_file+0x10c>
4001aad0:	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)
4001aad4:	a0 04 20 20 	add  %l0, 0x20, %l0                            
4001aad8:	80 a4 00 11 	cmp  %l0, %l1                                  
4001aadc:	0a bf ff e7 	bcs  4001aa78 <msdos_find_node_by_cluster_num_in_fat_file+0x60><== ALWAYS TAKEN
4001aae0:	ba 07 60 20 	add  %i5, 0x20, %i5                            
4001aae4:	10 bf ff d7 	b  4001aa40 <msdos_find_node_by_cluster_num_in_fat_file+0x28><== NOT EXECUTED
4001aae8:	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;                      
4001aaec:	31 00 00 1f 	sethi  %hi(0x7c00), %i0                        <== NOT EXECUTED
4001aaf0:	b0 16 21 01 	or  %i0, 0x101, %i0	! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
            }                                                         
        }                                                             
        j++;                                                          
    }                                                                 
    return MSDOS_NAME_NOT_FOUND_ERR;                                  
}                                                                     
4001aaf4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001aaf8:	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) &&                                 
4001aafc:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        <== NOT EXECUTED
4001ab00:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001ab04:	32 bf ff cb 	bne,a   4001aa30 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
4001ab08:	e2 14 a0 06 	lduh  [ %l2 + 6 ], %l1                         <== NOT EXECUTED
       (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))             
4001ab0c:	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) &&                                 
4001ab10:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
4001ab14:	22 bf ff c7 	be,a   4001aa30 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
4001ab18:	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;                               
4001ab1c:	10 bf ff c5 	b  4001aa30 <msdos_find_node_by_cluster_num_in_fat_file+0x18><== NOT EXECUTED
4001ab20:	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,
4001ab24:	92 10 00 19 	mov  %i1, %o1                                  
4001ab28:	94 10 20 01 	mov  1, %o2                                    
4001ab2c:	96 10 00 13 	mov  %l3, %o3                                  
4001ab30:	7f ff e4 86 	call  40013d48 <fat_file_ioctl>                
4001ab34:	98 10 00 1b 	mov  %i3, %o4                                  
                                    &dir_pos->sname.cln);             
                if (rc != RC_OK)                                      
4001ab38:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001ab3c:	12 bf ff ee 	bne  4001aaf4 <msdos_find_node_by_cluster_num_in_fat_file+0xdc><== NEVER TAKEN
4001ab40:	82 10 3f ff 	mov  -1, %g1                                   
                    return rc;                                        
                                                                      
                dir_pos->sname.ofs = i;                               
4001ab44:	e0 26 e0 04 	st  %l0, [ %i3 + 4 ]                           
                dir_pos->lname.cln = FAT_FILE_SHORT_NAME;             
4001ab48:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           
                dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;             
4001ab4c:	c2 26 e0 0c 	st  %g1, [ %i3 + 0xc ]                         
                                                                      
                memcpy(dir_entry, entry,                              
4001ab50:	90 10 00 1c 	mov  %i4, %o0                                  
4001ab54:	92 10 00 1d 	mov  %i5, %o1                                  
4001ab58:	40 00 0d 33 	call  4001e024 <memcpy>                        
4001ab5c:	94 10 20 20 	mov  0x20, %o2                                 
                       MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);            
                return RC_OK;                                         
4001ab60:	81 c7 e0 08 	ret                                            
4001ab64:	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 );              
4001ab68:	40 00 0a 8a 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001ab6c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001ab70:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001ab74:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001ab78:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ab7c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        assert(ret == bts2rd);                                        
4001ab80:	11 10 00 b8 	sethi  %hi(0x4002e000), %o0                    <== NOT EXECUTED
4001ab84:	15 10 00 b8 	sethi  %hi(0x4002e000), %o2                    <== NOT EXECUTED
4001ab88:	17 10 00 b8 	sethi  %hi(0x4002e000), %o3                    <== NOT EXECUTED
4001ab8c:	90 12 22 f8 	or  %o0, 0x2f8, %o0                            <== NOT EXECUTED
4001ab90:	92 10 26 4e 	mov  0x64e, %o1                                <== NOT EXECUTED
4001ab94:	94 12 a3 e8 	or  %o2, 0x3e8, %o2                            <== NOT EXECUTED
4001ab98:	7f ff ac 19 	call  40005bfc <__assert_func>                 <== NOT EXECUTED
4001ab9c:	96 12 e3 98 	or  %o3, 0x398, %o3                            <== NOT EXECUTED
                                                                      

4000e848 <msdos_format>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
4000e848:	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");
4000e84c:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000e850:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000e854:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000e858:	7f ff ff 41 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000e85c:	94 12 a0 d0 	or  %o2, 0xd0, %o2	! 4002dcd0 <_CPU_Trap_slot_template+0x68><== NOT EXECUTED
  fd = open(devname, O_RDWR);                                         
4000e860:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000e864:	7f ff e0 b2 	call  40006b2c <open>                          <== NOT EXECUTED
4000e868:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
  if (fd == -1) {                                                     
4000e86c:	80 a2 3f ff 	cmp  %o0, -1                                   <== NOT EXECUTED
4000e870:	02 80 01 88 	be  4000ee90 <msdos_format+0x648>              <== NOT EXECUTED
4000e874:	b6 10 00 08 	mov  %o0, %i3                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * sanity check on device                                           
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
4000e878:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000e87c:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000e880:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000e884:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000e888:	7f ff ff 35 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000e88c:	94 12 a1 a8 	or  %o2, 0x1a8, %o2	! 4002dda8 <_CPU_Trap_slot_template+0x140><== NOT EXECUTED
                       "stat check: %s\n", devname);                  
  if (ret_val == 0) {                                                 
    ret_val = fstat(fd, &stat_buf);                                   
4000e890:	92 07 bd 60 	add  %fp, -672, %o1                            <== NOT EXECUTED
4000e894:	7f ff dd 68 	call  40005e34 <fstat>                         <== NOT EXECUTED
4000e898:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,             
4000e89c:	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);                                   
4000e8a0:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,             
4000e8a4:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000e8a8:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000e8ac:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000e8b0:	7f ff ff 2b 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000e8b4:	94 12 a1 b8 	or  %o2, 0x1b8, %o2	! 4002ddb8 <_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))) {               
4000e8b8:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
4000e8bc:	12 80 00 0c 	bne  4000e8ec <msdos_format+0xa4>              <== NOT EXECUTED
4000e8c0:	c4 07 bd 6c 	ld  [ %fp + -660 ], %g2                        <== NOT EXECUTED
4000e8c4:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        <== NOT EXECUTED
4000e8c8:	84 08 80 01 	and  %g2, %g1, %g2                             <== NOT EXECUTED
4000e8cc:	03 00 00 18 	sethi  %hi(0x6000), %g1                        <== NOT EXECUTED
4000e8d0:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
4000e8d4:	02 80 00 13 	be  4000e920 <msdos_format+0xd8>               <== NOT EXECUTED
4000e8d8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
    errno = ENOTTY;                                                   
4000e8dc:	40 00 3b 2d 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000e8e0:	ae 10 3f ff 	mov  -1, %l7                                   <== NOT EXECUTED
4000e8e4:	82 10 20 19 	mov  0x19, %g1                                 <== NOT EXECUTED
4000e8e8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000e8ec:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000e8f0:	82 40 20 00 	addx  %g0, 0, %g1                              <== NOT EXECUTED
4000e8f4:	c2 2f bd 57 	stb  %g1, [ %fp + -681 ]                       <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * create master boot record                                        
   */                                                                 
  if (ret_val == 0) {                                                 
4000e8f8:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
4000e8fc:	02 80 00 7d 	be  4000eaf0 <msdos_format+0x2a8>              <== NOT EXECUTED
4000e900:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
  /*                                                                  
   * cleanup:                                                         
   * sync and unlock disk                                             
   * free any data structures (not needed now)                        
   */                                                                 
  if (fd != -1) {                                                     
4000e904:	80 a6 ff ff 	cmp  %i3, -1                                   <== NOT EXECUTED
4000e908:	02 80 00 04 	be  4000e918 <msdos_format+0xd0>               <== NOT EXECUTED
4000e90c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    close(fd);                                                        
4000e910:	7f ff dc fd 	call  40005d04 <close>                         <== NOT EXECUTED
4000e914:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
4000e918:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e91c:	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));                           
4000e920:	94 10 20 54 	mov  0x54, %o2                                 <== NOT EXECUTED
4000e924:	40 00 3d fd 	call  4001e118 <memset>                        <== NOT EXECUTED
4000e928:	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);    
4000e92c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000e930:	3b 10 01 10 	sethi  %hi(0x40044000), %i5                    <== NOT EXECUTED
4000e934:	94 07 bd ac 	add  %fp, -596, %o2                            <== NOT EXECUTED
4000e938:	40 00 1e 51 	call  4001627c <ioctl>                         <== NOT EXECUTED
4000e93c:	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) {                                                 
4000e940:	84 92 20 00 	orcc  %o0, 0, %g2                              <== NOT EXECUTED
4000e944:	02 80 01 62 	be  4000eecc <msdos_format+0x684>              <== NOT EXECUTED
4000e948:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000e94c:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000e950:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000e954:	82 40 20 00 	addx  %g0, 0, %g1                              <== NOT EXECUTED
4000e958:	c2 2f bd 57 	stb  %g1, [ %fp + -681 ]                       <== NOT EXECUTED
      }                                                               
                                                                      
      ++iteration_cnt;                                                
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
4000e95c:	80 a5 60 00 	cmp  %l5, 0                                    <== NOT EXECUTED
4000e960:	02 80 01 c7 	be  4000f07c <msdos_format+0x834>              <== NOT EXECUTED
4000e964:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000e968:	ae 10 00 02 	mov  %g2, %l7                                  <== NOT EXECUTED
4000e96c:	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;                              
4000e970:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * determine location and size of root directory                    
   * for formatting                                                   
   */                                                                 
  if (fmt_params->root_dir_sectors > 0) {                             
4000e974:	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);           
4000e978:	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) {                             
4000e97c:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4000e980:	02 80 01 c4 	be  4000f090 <msdos_format+0x848>              <== NOT EXECUTED
4000e984:	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);           
4000e988:	7f ff cf 01 	call  4000258c <.umul>                         <== NOT EXECUTED
4000e98c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;  
4000e990:	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);           
4000e994:	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 =                                  
4000e998:	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) {                                                 
4000e99c:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
4000e9a0:	12 80 00 46 	bne  4000eab8 <msdos_format+0x270>             <== NOT EXECUTED
4000e9a4:	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) &&                                           
4000e9a8:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4000e9ac:	02 80 03 8d 	be  4000f7e0 <msdos_format+0xf98>              <== NOT EXECUTED
4000e9b0:	09 10 00 b7 	sethi  %hi(0x4002dc00), %g4                    <== NOT EXECUTED
	(rqdata->OEMName != NULL)) {                                         
4000e9b4:	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) &&                                           
4000e9b8:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
4000e9bc:	22 80 03 89 	be,a   4000f7e0 <msdos_format+0xf98>           <== NOT EXECUTED
4000e9c0:	09 10 00 b7 	sethi  %hi(0x4002dc00), %g4                    <== NOT EXECUTED
4000e9c4:	03 10 00 bb 	sethi  %hi(0x4002ec00), %g1                    <== NOT EXECUTED
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
      }                                                               
    }                                                                 
    else {                                                            
      fmt_params->media_code = FAT_BR_MEDIA_FIXED;                    
4000e9c8:	84 10 20 08 	mov  8, %g2                                    <== NOT EXECUTED
4000e9cc:	f4 00 61 48 	ld  [ %g1 + 0x148 ], %i2                       <== NOT EXECUTED
	/*                                                                   
	 * non-printable character in given name, so keep stuck              
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
4000e9d0:	b0 10 20 20 	mov  0x20, %i0                                 <== NOT EXECUTED
  /*                                                                  
   * determine usable OEMName                                         
   */                                                                 
  if (ret_val == 0) {                                                 
      const char *from;                                               
      char        *to = fmt_params->OEMName;                          
4000e9d4:	10 80 00 07 	b  4000e9f0 <msdos_format+0x1a8>               <== NOT EXECUTED
4000e9d8:	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++;                                                     
4000e9dc:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
      }                                                               
      *to = '\0';                                                     
4000e9e0:	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;                                                     
4000e9e4:	84 80 bf ff 	addcc  %g2, -1, %g2                            <== NOT EXECUTED
4000e9e8:	02 80 00 0e 	be  4000ea20 <msdos_format+0x1d8>              <== NOT EXECUTED
4000e9ec:	88 01 20 01 	inc  %g4                                       <== NOT EXECUTED
	 cnt < (sizeof(fmt_params->OEMName)-1);                              
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
4000e9f0:	c6 09 00 00 	ldub  [ %g4 ], %g3                             <== NOT EXECUTED
4000e9f4:	ba 08 e0 ff 	and  %g3, 0xff, %i5                            <== NOT EXECUTED
4000e9f8:	ba 06 80 1d 	add  %i2, %i5, %i5                             <== NOT EXECUTED
4000e9fc:	fa 4f 60 01 	ldsb  [ %i5 + 1 ], %i5                         <== NOT EXECUTED
4000ea00:	80 8f 60 97 	btst  0x97, %i5                                <== NOT EXECUTED
4000ea04:	32 bf ff f6 	bne,a   4000e9dc <msdos_format+0x194>          <== NOT EXECUTED
4000ea08:	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++=' ';                                                           
4000ea0c:	f0 28 40 00 	stb  %i0, [ %g1 ]                              <== NOT EXECUTED
4000ea10:	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;                                                     
4000ea14:	84 80 bf ff 	addcc  %g2, -1, %g2                            <== NOT EXECUTED
4000ea18:	12 bf ff f6 	bne  4000e9f0 <msdos_format+0x1a8>             <== NOT EXECUTED
4000ea1c:	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) &&                                           
4000ea20:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4000ea24:	02 80 03 71 	be  4000f7e8 <msdos_format+0xfa0>              <== NOT EXECUTED
4000ea28:	09 10 00 b7 	sethi  %hi(0x4002dc00), %g4                    <== NOT EXECUTED
	(rqdata->VolLabel != NULL)) {                                        
4000ea2c:	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) &&                                           
4000ea30:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
4000ea34:	22 80 03 6d 	be,a   4000f7e8 <msdos_format+0xfa0>           <== NOT EXECUTED
4000ea38:	09 10 00 b7 	sethi  %hi(0x4002dc00), %g4                    <== NOT EXECUTED
	(rqdata->VolLabel != NULL)) {                                        
      from = rqdata->VolLabel;                                        
      fmt_params->VolLabel_present = true;                            
4000ea3c:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4000ea40:	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;                    
4000ea44:	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;                         
4000ea48:	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++=' ';                                                           
4000ea4c:	10 80 00 07 	b  4000ea68 <msdos_format+0x220>               <== NOT EXECUTED
4000ea50:	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++;                                                     
4000ea54:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
	 * at that character and replace all following characters            
	 * with a ' '                                                        
	 */                                                                  
	*to++=' ';                                                           
      }                                                               
      *to = '\0';                                                     
4000ea58:	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;                                                     
4000ea5c:	84 80 bf ff 	addcc  %g2, -1, %g2                            <== NOT EXECUTED
4000ea60:	02 80 00 0e 	be  4000ea98 <msdos_format+0x250>              <== NOT EXECUTED
4000ea64:	88 01 20 01 	inc  %g4                                       <== NOT EXECUTED
	 cnt < (sizeof(fmt_params->VolLabel)-1);                             
	 cnt++) {                                                            
      if (isprint((unsigned char)*from)) {                            
4000ea68:	c6 09 00 00 	ldub  [ %g4 ], %g3                             <== NOT EXECUTED
4000ea6c:	ba 08 e0 ff 	and  %g3, 0xff, %i5                            <== NOT EXECUTED
4000ea70:	ba 06 80 1d 	add  %i2, %i5, %i5                             <== NOT EXECUTED
4000ea74:	fa 4f 60 01 	ldsb  [ %i5 + 1 ], %i5                         <== NOT EXECUTED
4000ea78:	80 8f 60 97 	btst  0x97, %i5                                <== NOT EXECUTED
4000ea7c:	32 bf ff f6 	bne,a   4000ea54 <msdos_format+0x20c>          <== NOT EXECUTED
4000ea80:	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++=' ';                                                           
4000ea84:	f0 28 40 00 	stb  %i0, [ %g1 ]                              <== NOT EXECUTED
4000ea88:	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;                                                     
4000ea8c:	84 80 bf ff 	addcc  %g2, -1, %g2                            <== NOT EXECUTED
4000ea90:	12 bf ff f6 	bne  4000ea68 <msdos_format+0x220>             <== NOT EXECUTED
4000ea94:	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);                      
4000ea98:	40 00 22 51 	call  400173dc <rtems_clock_get_tod_timeval>   <== NOT EXECUTED
4000ea9c:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
  if (rc == RTEMS_SUCCESSFUL) {                                       
4000eaa0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000eaa4:	12 80 03 3d 	bne  4000f798 <msdos_format+0xf50>             <== NOT EXECUTED
4000eaa8:	c2 07 be 00 	ld  [ %fp + -512 ], %g1                        <== NOT EXECUTED
    *volid_ptr = time_value.tv_sec + time_value.tv_sec;               
4000eaac:	83 28 60 01 	sll  %g1, 1, %g1                               <== NOT EXECUTED
4000eab0:	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) &&                                               
4000eab4:	80 8f 20 ff 	btst  0xff, %i4                                <== NOT EXECUTED
4000eab8:	02 bf ff 91 	be  4000e8fc <msdos_format+0xb4>               <== NOT EXECUTED
4000eabc:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
      (rqdata != NULL) &&                                             
4000eac0:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      <== NOT EXECUTED
4000eac4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000eac8:	12 80 00 0a 	bne  4000eaf0 <msdos_format+0x2a8>             <== NOT EXECUTED
4000eacc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
      !(rqdata->quick_format)) {                                      
    ret_val = msdos_format_fill_sectors                               
4000ead0:	d6 07 bd b0 	ld  [ %fp + -592 ], %o3                        <== NOT EXECUTED
4000ead4:	d8 07 bd ac 	ld  [ %fp + -596 ], %o4                        <== NOT EXECUTED
4000ead8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000eadc:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000eae0:	7f ff fe cc 	call  4000e610 <msdos_format_fill_sectors>     <== NOT EXECUTED
4000eae4:	9a 10 3f e5 	mov  -27, %o5                                  <== NOT EXECUTED
4000eae8:	10 bf ff 84 	b  4000e8f8 <msdos_format+0xb0>                <== NOT EXECUTED
4000eaec:	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,         
4000eaf0:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000eaf4:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000eaf8:	7f ff fe 99 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000eafc:	94 12 a1 58 	or  %o2, 0x158, %o2	! 4002dd58 <_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)) {     
4000eb00:	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,                               
4000eb04:	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)) {     
4000eb08:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000eb0c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000eb10:	40 00 1d fc 	call  40016300 <lseek>                         <== NOT EXECUTED
4000eb14:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
4000eb18:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000eb1c:	06 80 01 16 	bl  4000ef74 <msdos_format+0x72c>              <== NOT EXECUTED
4000eb20:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
  if (ret_val == 0) {                                                 
    if (0 > read(fd,buffer,sector_size)) {                            
4000eb24:	92 07 be 00 	add  %fp, -512, %o1                            <== NOT EXECUTED
4000eb28:	40 00 1e cc 	call  40016658 <read>                          <== NOT EXECUTED
4000eb2c:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4000eb30:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000eb34:	06 80 01 10 	bl  4000ef74 <msdos_format+0x72c>              <== NOT EXECUTED
4000eb38:	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,       
4000eb3c:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000eb40:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000eb44:	7f ff fe 86 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000eb48:	94 12 a1 c8 	or  %o2, 0x1c8, %o2	! 4002ddc8 <_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) {                        
4000eb4c:	c2 07 bd b0 	ld  [ %fp + -592 ], %g1                        <== NOT EXECUTED
4000eb50:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        <== NOT EXECUTED
4000eb54:	84 10 a3 ff 	or  %g2, 0x3ff, %g2	! ffff <PROM_START+0xffff> <== NOT EXECUTED
4000eb58:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
4000eb5c:	08 80 02 f9 	bleu  4000f740 <msdos_format+0xef8>            <== NOT EXECUTED
4000eb60:	b0 10 00 01 	mov  %g1, %i0                                  <== NOT EXECUTED
4000eb64:	84 08 40 02 	and  %g1, %g2, %g2                             <== NOT EXECUTED
4000eb68:	a8 10 00 01 	mov  %g1, %l4                                  <== NOT EXECUTED
4000eb6c:	a7 30 a0 08 	srl  %g2, 8, %l3                               <== NOT EXECUTED
4000eb70:	a5 30 60 10 	srl  %g1, 0x10, %l2                            <== NOT EXECUTED
4000eb74:	a3 30 60 18 	srl  %g1, 0x18, %l1                            <== NOT EXECUTED
4000eb78:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
4000eb7c:	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);                     
4000eb80:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000eb84:	94 10 21 be 	mov  0x1be, %o2                                <== NOT EXECUTED
4000eb88:	40 00 3d 64 	call  4001e118 <memset>                        <== NOT EXECUTED
4000eb8c:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
   * with 0xEB,....                                                   
   */                                                                 
  /*                                                                  
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
4000eb90:	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,
4000eb94:	c0 37 bf fe 	clrh  [ %fp + -2 ]                             <== NOT EXECUTED
   * with 0xEB,....                                                   
   */                                                                 
  /*                                                                  
   * fill OEMName                                                     
   */                                                                 
  memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),                                
4000eb98:	92 07 bd df 	add  %fp, -545, %o1                            <== NOT EXECUTED
4000eb9c:	40 00 3d 22 	call  4001e024 <memcpy>                        <== NOT EXECUTED
4000eba0:	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);
4000eba4:	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); 
4000eba8:	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);
4000ebac:	83 30 a0 08 	srl  %g2, 8, %g1                               <== NOT EXECUTED
4000ebb0:	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);       
4000ebb4:	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);  
4000ebb8:	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); 
4000ebbc:	9b 31 20 08 	srl  %g4, 8, %o5                               <== NOT EXECUTED
4000ebc0:	c8 2f be 0b 	stb  %g4, [ %fp + -501 ]                       <== NOT EXECUTED
  FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
4000ebc4:	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) {                             
4000ebc8:	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);       
4000ebcc:	c2 2f be 15 	stb  %g1, [ %fp + -491 ]                       <== NOT EXECUTED
                                                                      
  FAT_SET_BR_SECTORS_PER_TRACK(mbr   , 255); /* only needed for INT13... */
4000ebd0:	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);  
4000ebd4:	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 */
4000ebd8:	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... */
4000ebdc:	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... */
4000ebe0:	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); 
4000ebe4:	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... */
4000ebe8:	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);
4000ebec:	c8 2f be 0d 	stb  %g4, [ %fp + -499 ]                       <== NOT EXECUTED
  FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);  
4000ebf0:	c6 2f be 0e 	stb  %g3, [ %fp + -498 ]                       <== NOT EXECUTED
4000ebf4:	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 */
4000ebf8:	f4 2f be 10 	stb  %i2, [ %fp + -496 ]                       <== NOT EXECUTED
  FAT_SET_BR_FILES_PER_ROOT_DIR(mbr  , fmt_params->files_per_root_dir);
4000ebfc:	c4 2f be 11 	stb  %g2, [ %fp + -495 ]                       <== NOT EXECUTED
  FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);          
4000ec00:	f0 2f be 13 	stb  %i0, [ %fp + -493 ]                       <== NOT EXECUTED
4000ec04:	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... */
4000ec08:	c2 2f be 1a 	stb  %g1, [ %fp + -486 ]                       <== NOT EXECUTED
  FAT_SET_BR_HIDDEN_SECTORS(mbr      , 1);   /* only needed for INT13... */
4000ec0c:	f8 2f be 1c 	stb  %i4, [ %fp + -484 ]                       <== NOT EXECUTED
                                                                      
  FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);          
4000ec10:	e8 2f be 20 	stb  %l4, [ %fp + -480 ]                       <== NOT EXECUTED
4000ec14:	e6 2f be 21 	stb  %l3, [ %fp + -479 ]                       <== NOT EXECUTED
4000ec18:	e4 2f be 22 	stb  %l2, [ %fp + -478 ]                       <== NOT EXECUTED
  if (fmt_params->fattype != FAT_FAT32) {                             
4000ec1c:	80 a7 60 04 	cmp  %i5, 4                                    <== NOT EXECUTED
4000ec20:	02 80 02 f7 	be  4000f7fc <msdos_format+0xfb4>              <== NOT EXECUTED
4000ec24:	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 */
4000ec28:	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);   
4000ec2c:	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 */
4000ec30:	89 30 60 10 	srl  %g1, 0x10, %g4                            <== NOT EXECUTED
4000ec34:	87 30 60 18 	srl  %g1, 0x18, %g3                            <== NOT EXECUTED
4000ec38:	b9 30 60 08 	srl  %g1, 8, %i4                               <== NOT EXECUTED
4000ec3c:	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);           
4000ec40:	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);   
4000ec44:	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);           
4000ec48:	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);   
4000ec4c:	c4 2f be 16 	stb  %g2, [ %fp + -490 ]                       <== NOT EXECUTED
4000ec50:	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 */
4000ec54:	f8 2f be 28 	stb  %i4, [ %fp + -472 ]                       <== NOT EXECUTED
4000ec58:	c8 2f be 29 	stb  %g4, [ %fp + -471 ]                       <== NOT EXECUTED
4000ec5c:	c6 2f be 2a 	stb  %g3, [ %fp + -470 ]                       <== NOT EXECUTED
  memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),                                 
4000ec60:	90 07 be 2b 	add  %fp, -469, %o0                            <== NOT EXECUTED
4000ec64:	92 07 bd e8 	add  %fp, -536, %o1                            <== NOT EXECUTED
4000ec68:	40 00 3c ef 	call  4001e024 <memcpy>                        <== NOT EXECUTED
4000ec6c:	94 10 20 0b 	mov  0xb, %o2                                  <== NOT EXECUTED
	 fmt_params->VolLabel,                                               
	 FAT_BR_VOLLAB_SIZE);                                                
    memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),                           
4000ec70:	03 10 00 b7 	sethi  %hi(0x4002dc00), %g1                    <== NOT EXECUTED
4000ec74:	80 a7 60 01 	cmp  %i5, 1                                    <== NOT EXECUTED
4000ec78:	02 80 02 c2 	be  4000f780 <msdos_format+0xf38>              <== NOT EXECUTED
4000ec7c:	82 10 60 b8 	or  %g1, 0xb8, %g1                             <== NOT EXECUTED
4000ec80:	c4 10 40 00 	lduh  [ %g1 ], %g2                             <== NOT EXECUTED
4000ec84:	c4 37 be 36 	sth  %g2, [ %fp + -458 ]                       <== NOT EXECUTED
4000ec88:	c4 10 60 02 	lduh  [ %g1 + 2 ], %g2                         <== NOT EXECUTED
4000ec8c:	c4 37 be 38 	sth  %g2, [ %fp + -456 ]                       <== NOT EXECUTED
4000ec90:	c4 10 60 04 	lduh  [ %g1 + 4 ], %g2                         <== NOT EXECUTED
4000ec94:	c4 37 be 3a 	sth  %g2, [ %fp + -454 ]                       <== NOT EXECUTED
4000ec98:	c2 10 60 06 	lduh  [ %g1 + 6 ], %g1                         <== NOT EXECUTED
4000ec9c:	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);               
4000eca0:	82 10 20 55 	mov  0x55, %g1                                 <== NOT EXECUTED
4000eca4:	c2 2f bf fe 	stb  %g1, [ %fp + -2 ]                         <== NOT EXECUTED
4000eca8:	82 10 3f aa 	mov  -86, %g1                                  <== NOT EXECUTED
4000ecac:	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);                                           
4000ecb0:	82 10 3f eb 	mov  -21, %g1                                  <== NOT EXECUTED
4000ecb4:	c2 2f be 00 	stb  %g1, [ %fp + -512 ]                       <== NOT EXECUTED
  FAT_SET_VAL8(mbr,1,0x3c);                                           
4000ecb8:	82 10 20 3c 	mov  0x3c, %g1                                 <== NOT EXECUTED
4000ecbc:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       <== NOT EXECUTED
  FAT_SET_VAL8(mbr,2,0x90);                                           
4000ecc0:	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,       
4000ecc4:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000ecc8:	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);                                           
4000eccc:	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,       
4000ecd0:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000ecd4:	7f ff fe 22 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000ecd8:	94 12 a1 70 	or  %o2, 0x170, %o2	! 4002dd70 <_CPU_Trap_slot_template+0x108><== NOT EXECUTED
                           "write MRB sector\n");                     
      ret_val = msdos_format_write_sec(fd,                            
4000ecdc:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        <== NOT EXECUTED
4000ece0:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000ece4:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000ece8:	7f ff fe 32 	call  4000e5b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000ecec:	96 07 be 00 	add  %fp, -512, %o3                            <== NOT EXECUTED
                                       0,                             
                                       fmt_params.bytes_per_sector,   
                                       tmp_sec);                      
    }                                                                 
    if ((ret_val == 0) &&                                             
4000ecf0:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000ecf4:	12 bf ff 04 	bne  4000e904 <msdos_format+0xbc>              <== NOT EXECUTED
4000ecf8:	c2 07 bd d4 	ld  [ %fp + -556 ], %g1                        <== NOT EXECUTED
4000ecfc:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000ed00:	12 80 02 aa 	bne  4000f7a8 <msdos_format+0xf60>             <== NOT EXECUTED
4000ed04:	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)) {                                 
4000ed08:	fa 07 bd d8 	ld  [ %fp + -552 ], %i5                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
  /*                                                                  
   * for FAT32: initialize info sector on disk                        
   */                                                                 
  if ((ret_val == 0) &&                                               
4000ed0c:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
4000ed10:	12 80 00 9b 	bne  4000ef7c <msdos_format+0x734>             <== NOT EXECUTED
4000ed14:	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,                                                        
4000ed18:	d0 0f bd dc 	ldub  [ %fp + -548 ], %o0                      <== NOT EXECUTED
4000ed1c:	7f ff ce 1c 	call  4000258c <.umul>                         <== NOT EXECUTED
4000ed20:	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                               
4000ed24:	d8 07 bd ac 	ld  [ %fp + -596 ], %o4                        <== NOT EXECUTED
      (rqdata,                                                        
4000ed28:	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                               
4000ed2c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000ed30:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000ed34:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4000ed38:	7f ff fe 36 	call  4000e610 <msdos_format_fill_sectors>     <== NOT EXECUTED
4000ed3c:	9a 10 20 00 	clr  %o5                                       <== NOT EXECUTED
  }                                                                   
  /*                                                                  
   * clear/init root directory                                        
   * -> write all directory sectors as 0x00                           
   */                                                                 
  if (ret_val == 0) {                                                 
4000ed40:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000ed44:	12 bf fe f0 	bne  4000e904 <msdos_format+0xbc>              <== NOT EXECUTED
4000ed48:	d4 07 bd cc 	ld  [ %fp + -564 ], %o2                        <== NOT EXECUTED
    ret_val = msdos_format_fill_sectors                               
4000ed4c:	d6 07 bd d0 	ld  [ %fp + -560 ], %o3                        <== NOT EXECUTED
4000ed50:	d8 07 bd ac 	ld  [ %fp + -596 ], %o4                        <== NOT EXECUTED
4000ed54:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000ed58:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000ed5c:	7f ff fe 2d 	call  4000e610 <msdos_format_fill_sectors>     <== NOT EXECUTED
4000ed60:	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) {                
4000ed64:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000ed68:	12 bf fe e7 	bne  4000e904 <msdos_format+0xbc>              <== NOT EXECUTED
4000ed6c:	c2 0f bd f4 	ldub  [ %fp + -524 ], %g1                      <== NOT EXECUTED
4000ed70:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000ed74:	12 80 00 a9 	bne  4000f018 <msdos_format+0x7d0>             <== NOT EXECUTED
4000ed78:	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));                                
4000ed7c:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
4000ed80:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000ed84:	40 00 3c e5 	call  4001e118 <memset>                        <== NOT EXECUTED
4000ed88:	94 10 22 00 	mov  0x200, %o2                                <== NOT EXECUTED
                                                                      
    switch(fmt_params.fattype) {                                      
4000ed8c:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
4000ed90:	80 a0 60 02 	cmp  %g1, 2                                    <== NOT EXECUTED
4000ed94:	02 80 00 e2 	be  4000f11c <msdos_format+0x8d4>              <== NOT EXECUTED
4000ed98:	80 a0 60 04 	cmp  %g1, 4                                    <== NOT EXECUTED
4000ed9c:	02 80 00 c4 	be  4000f0ac <msdos_format+0x864>              <== NOT EXECUTED
4000eda0:	80 a0 60 01 	cmp  %g1, 1                                    <== NOT EXECUTED
4000eda4:	02 80 00 d7 	be  4000f100 <msdos_format+0x8b8>              <== NOT EXECUTED
4000eda8:	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;                                                 
4000edac:	40 00 39 f9 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000edb0:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000edb4:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
4000edb8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    }                                                                 
    if (fmt_params.fattype == FAT_FAT32) {                            
4000edbc:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
4000edc0:	80 a0 60 04 	cmp  %g1, 4                                    <== NOT EXECUTED
4000edc4:	02 80 00 c7 	be  4000f0e0 <msdos_format+0x898>              <== NOT EXECUTED
4000edc8:	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)                                               
4000edcc:	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,      
4000edd0:	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)                                               
4000edd4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000edd8:	12 80 00 06 	bne  4000edf0 <msdos_format+0x5a8>             <== NOT EXECUTED
4000eddc:	c4 07 bd b8 	ld  [ %fp + -584 ], %g2                        <== NOT EXECUTED
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000ede0:	b8 07 00 02 	add  %i4, %g2, %i4                             <== NOT EXECUTED
4000ede4:	84 20 00 02 	neg  %g2                                       <== NOT EXECUTED
4000ede8:	b8 07 3f ff 	add  %i4, -1, %i4                              <== NOT EXECUTED
4000edec:	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;                                                       
4000edf0:	c2 0f bd dc 	ldub  [ %fp + -548 ], %g1                      <== NOT EXECUTED
4000edf4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000edf8:	02 80 02 b0 	be  4000f8b8 <msdos_format+0x1070>             <== NOT EXECUTED
4000edfc:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
4000ee00:	12 80 00 5a 	bne  4000ef68 <msdos_format+0x720>             <== NOT EXECUTED
4000ee04:	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;                                                       
4000ee08:	10 80 00 05 	b  4000ee1c <msdos_format+0x5d4>               <== NOT EXECUTED
4000ee0c:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
	 (i < fmt_params.fat_num) && (ret_val == 0);                         
4000ee10:	32 bf fe bd 	bne,a   4000e904 <msdos_format+0xbc>           <== NOT EXECUTED
4000ee14:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
4000ee18:	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),                          
4000ee1c:	7f ff cd dc 	call  4000258c <.umul>                         <== NOT EXECUTED
4000ee20:	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                                
4000ee24:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        <== NOT EXECUTED
        (fd,                                                          
4000ee28:	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                                
4000ee2c:	96 07 be 00 	add  %fp, -512, %o3                            <== NOT EXECUTED
4000ee30:	7f ff fd e0 	call  4000e5b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000ee34:	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);                         
4000ee38:	c2 0f bd dc 	ldub  [ %fp + -548 ], %g1                      <== NOT EXECUTED
	 i++) {                                                              
4000ee3c:	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;                                                       
4000ee40:	80 a0 40 1d 	cmp  %g1, %i5                                  <== NOT EXECUTED
4000ee44:	14 bf ff f3 	bg  4000ee10 <msdos_format+0x5c8>              <== NOT EXECUTED
4000ee48:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000ee4c:	c4 0f bd 57 	ldub  [ %fp + -681 ], %g2                      <== NOT EXECUTED
4000ee50:	80 a0 00 08 	cmp  %g0, %o0                                  <== NOT EXECUTED
4000ee54:	82 60 3f ff 	subx  %g0, -1, %g1                             <== NOT EXECUTED
4000ee58:	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) {        
4000ee5c:	80 88 60 ff 	btst  0xff, %g1                                <== NOT EXECUTED
4000ee60:	22 bf fe a9 	be,a   4000e904 <msdos_format+0xbc>            <== NOT EXECUTED
4000ee64:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
4000ee68:	c2 0e 60 17 	ldub  [ %i1 + 0x17 ], %g1                      <== NOT EXECUTED
4000ee6c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000ee70:	02 bf fe a6 	be  4000e908 <msdos_format+0xc0>               <== NOT EXECUTED
4000ee74:	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);                              
4000ee78:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000ee7c:	13 08 00 10 	sethi  %hi(0x20004000), %o1                    <== NOT EXECUTED
4000ee80:	40 00 1c ff 	call  4001627c <ioctl>                         <== NOT EXECUTED
4000ee84:	92 12 62 06 	or  %o1, 0x206, %o1	! 20004206 <RAM_SIZE+0x1fc04206><== NOT EXECUTED
4000ee88:	10 bf fe 9f 	b  4000e904 <msdos_format+0xbc>                <== NOT EXECUTED
4000ee8c:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * sanity check on device                                           
   */                                                                 
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
4000ee90:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000ee94:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000ee98:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000ee9c:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000eea0:	7f ff fd af 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000eea4:	94 12 a1 a8 	or  %o2, 0x1a8, %o2	! 4002dda8 <_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,             
4000eea8:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000eeac:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4000eeb0:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000eeb4:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000eeb8:	ae 10 3f ff 	mov  -1, %l7                                   <== NOT EXECUTED
4000eebc:	7f ff fd a8 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000eec0:	94 12 a1 b8 	or  %o2, 0x1b8, %o2                            <== NOT EXECUTED
4000eec4:	10 bf fe 8b 	b  4000e8f0 <msdos_format+0xa8>                <== NOT EXECUTED
4000eec8:	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);                 
4000eecc:	92 17 62 05 	or  %i5, 0x205, %o1                            <== NOT EXECUTED
4000eed0:	40 00 1c eb 	call  4001627c <ioctl>                         <== NOT EXECUTED
4000eed4:	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) {                                                 
4000eed8:	84 92 20 00 	orcc  %o0, 0, %g2                              <== NOT EXECUTED
4000eedc:	12 bf fe 9c 	bne  4000e94c <msdos_format+0x104>             <== NOT EXECUTED
4000eee0:	f0 07 bd ac 	ld  [ %fp + -596 ], %i0                        <== NOT EXECUTED
    total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
4000eee4:	f4 07 bd b0 	ld  [ %fp + -592 ], %i2                        <== NOT EXECUTED
4000eee8:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4000eeec:	7f ff cd a8 	call  4000258c <.umul>                         <== NOT EXECUTED
4000eef0:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000eef4:	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;
4000eef8:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000eefc:	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;
4000ef00:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,         
4000ef04:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000ef08:	f8 3f bd 58 	std  %i4, [ %fp + -680 ]                       <== NOT EXECUTED
4000ef0c:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000ef10:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4000ef14:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000ef18:	98 10 00 1a 	mov  %i2, %o4                                  <== NOT EXECUTED
4000ef1c:	7f ff fd 90 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000ef20:	94 12 a0 e0 	or  %o2, 0xe0, %o2                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
4000ef24:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4000ef28:	02 80 02 69 	be  4000f8cc <msdos_format+0x1084>             <== NOT EXECUTED
4000ef2c:	82 10 20 02 	mov  2, %g1                                    <== NOT EXECUTED
	(rqdata->fat_num == 0)) {                                            
4000ef30:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         <== NOT EXECUTED
                                                                      
  /*                                                                  
   * determine number of FATs                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata == NULL) ||                                           
4000ef34:	80 a2 e0 00 	cmp  %o3, 0                                    <== NOT EXECUTED
4000ef38:	22 80 00 82 	be,a   4000f140 <msdos_format+0x8f8>           <== NOT EXECUTED
4000ef3c:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
	(rqdata->fat_num == 0)) {                                            
      fmt_params->fat_num = 2;                                        
    }                                                                 
    else if (rqdata->fat_num <= 6) {                                  
4000ef40:	80 a2 e0 06 	cmp  %o3, 6                                    <== NOT EXECUTED
4000ef44:	18 80 02 09 	bgu  4000f768 <msdos_format+0xf20>             <== NOT EXECUTED
4000ef48:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
      fmt_params->fat_num = rqdata->fat_num;                          
4000ef4c:	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,         
4000ef50:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000ef54:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000ef58:	7f ff fd 81 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000ef5c:	94 12 a1 20 	or  %o2, 0x120, %o2	! 4002dd20 <_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) {         
4000ef60:	10 80 00 7f 	b  4000f15c <msdos_format+0x914>               <== NOT EXECUTED
4000ef64:	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);                         
4000ef68:	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) {        
4000ef6c:	10 bf fe 66 	b  4000e904 <msdos_format+0xbc>                <== NOT EXECUTED
4000ef70:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
      }                                                               
                                                                      
      ++iteration_cnt;                                                
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
4000ef74:	10 bf fe 64 	b  4000e904 <msdos_format+0xbc>                <== NOT EXECUTED
4000ef78:	ae 10 3f ff 	mov  -1, %l7                                   <== NOT EXECUTED
\*=========================================================================*/
{                                                                     
  /*                                                                  
   * clear fsinfo sector data                                         
   */                                                                 
  memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);                             
4000ef7c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000ef80:	94 10 22 00 	mov  0x200, %o2                                <== NOT EXECUTED
4000ef84:	40 00 3c 65 	call  4001e118 <memset>                        <== NOT EXECUTED
4000ef88:	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 );
4000ef8c:	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,                              
4000ef90:	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 );
4000ef94:	c4 2f be 02 	stb  %g2, [ %fp + -510 ]                       <== NOT EXECUTED
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000ef98:	c4 2f bf e7 	stb  %g2, [ %fp + -25 ]                        <== NOT EXECUTED
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000ef9c:	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,              
4000efa0:	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 );
4000efa4:	86 10 20 41 	mov  0x41, %g3                                 <== NOT EXECUTED
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000efa8:	88 10 20 72 	mov  0x72, %g4                                 <== NOT EXECUTED
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000efac:	c4 2f bf fe 	stb  %g2, [ %fp + -2 ]                         <== NOT EXECUTED
4000efb0:	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 );
4000efb4:	b8 10 20 52 	mov  0x52, %i4                                 <== NOT EXECUTED
4000efb8:	c6 2f be 03 	stb  %g3, [ %fp + -509 ]                       <== NOT EXECUTED
4000efbc:	f8 2f be 00 	stb  %i4, [ %fp + -512 ]                       <== NOT EXECUTED
4000efc0:	f8 2f be 01 	stb  %i4, [ %fp + -511 ]                       <== NOT EXECUTED
  FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
4000efc4:	c8 2f bf e4 	stb  %g4, [ %fp + -28 ]                        <== NOT EXECUTED
4000efc8:	c8 2f bf e5 	stb  %g4, [ %fp + -27 ]                        <== NOT EXECUTED
4000efcc:	c6 2f bf e6 	stb  %g3, [ %fp + -26 ]                        <== NOT EXECUTED
  FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
4000efd0:	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,              
4000efd4:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        <== NOT EXECUTED
4000efd8:	c2 2f bf e9 	stb  %g1, [ %fp + -23 ]                        <== NOT EXECUTED
4000efdc:	c2 2f bf ea 	stb  %g1, [ %fp + -22 ]                        <== NOT EXECUTED
4000efe0:	c2 2f bf eb 	stb  %g1, [ %fp + -21 ]                        <== NOT EXECUTED
				    0xffffffff);                                                  
  FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,              
4000efe4:	c2 2f bf ec 	stb  %g1, [ %fp + -20 ]                        <== NOT EXECUTED
4000efe8:	c2 2f bf ed 	stb  %g1, [ %fp + -19 ]                        <== NOT EXECUTED
4000efec:	c2 2f bf ee 	stb  %g1, [ %fp + -18 ]                        <== NOT EXECUTED
4000eff0:	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,                              
4000eff4:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000eff8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4000effc:	7f ff fd 6d 	call  4000e5b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000f000:	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) {                                                 
4000f004:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000f008:	12 bf fe 40 	bne  4000e908 <msdos_format+0xc0>              <== NOT EXECUTED
4000f00c:	80 a6 ff ff 	cmp  %i3, -1                                   <== NOT EXECUTED
    ret_val = msdos_format_fill_sectors                               
      (rqdata,                                                        
4000f010:	10 bf ff 42 	b  4000ed18 <msdos_format+0x4d0>               <== NOT EXECUTED
4000f014:	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));                                
4000f018:	94 10 22 00 	mov  0x200, %o2                                <== NOT EXECUTED
4000f01c:	40 00 3c 3f 	call  4001e118 <memset>                        <== NOT EXECUTED
4000f020:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
    memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
4000f024:	c2 0f bd f2 	ldub  [ %fp + -526 ], %g1                      <== NOT EXECUTED
4000f028:	c6 07 bd ec 	ld  [ %fp + -532 ], %g3                        <== NOT EXECUTED
4000f02c:	c4 17 bd f0 	lduh  [ %fp + -528 ], %g2                      <== NOT EXECUTED
4000f030:	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                                  
4000f034:	d2 07 bd cc 	ld  [ %fp + -564 ], %o1                        <== NOT EXECUTED
4000f038:	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);
4000f03c:	c2 2f be 0a 	stb  %g1, [ %fp + -502 ]                       <== NOT EXECUTED
    *MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;                  
4000f040:	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);
4000f044:	c8 27 be 00 	st  %g4, [ %fp + -512 ]                        <== NOT EXECUTED
4000f048:	c6 27 be 04 	st  %g3, [ %fp + -508 ]                        <== NOT EXECUTED
4000f04c:	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                                  
4000f050:	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;                  
4000f054:	c2 2f be 0b 	stb  %g1, [ %fp + -501 ]                       <== NOT EXECUTED
    ret_val = msdos_format_write_sec                                  
4000f058:	7f ff fd 56 	call  4000e5b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000f05c:	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) {                                                 
4000f060:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000f064:	22 bf ff 47 	be,a   4000ed80 <msdos_format+0x538>           <== NOT EXECUTED
4000f068:	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) {        
4000f06c:	10 bf fe 26 	b  4000e904 <msdos_format+0xbc>                <== NOT EXECUTED
4000f070:	ae 10 00 08 	mov  %o0, %l7                                  <== NOT EXECUTED
4000f074:	82 40 20 00 	addx  %g0, 0, %g1                              <== NOT EXECUTED
4000f078:	c2 2f bd 57 	stb  %g1, [ %fp + -681 ]                       <== NOT EXECUTED
      ++iteration_cnt;                                                
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
  {                                                                   
    errno = EINVAL;                                                   
4000f07c:	40 00 39 45 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000f080:	ae 10 3f ff 	mov  -1, %l7                                   <== NOT EXECUTED
4000f084:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4000f088:	10 bf fe 39 	b  4000e96c <msdos_format+0x124>               <== NOT EXECUTED
4000f08c:	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);           
4000f090:	7f ff cd 3f 	call  4000258c <.umul>                         <== NOT EXECUTED
4000f094:	01 00 00 00 	nop                                            <== NOT EXECUTED
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000f098:	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);           
4000f09c:	90 07 40 08 	add  %i5, %o0, %o0                             <== NOT EXECUTED
    fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
4000f0a0:	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 =                                  
4000f0a4:	10 bf fe 3e 	b  4000e99c <msdos_format+0x154>               <== NOT EXECUTED
4000f0a8:	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);      
4000f0ac:	c4 0f bd dd 	ldub  [ %fp + -547 ], %g2                      <== NOT EXECUTED
4000f0b0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
4000f0b4:	c4 2f be 00 	stb  %g2, [ %fp + -512 ]                       <== NOT EXECUTED
4000f0b8:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       <== NOT EXECUTED
4000f0bc:	c2 2f be 02 	stb  %g1, [ %fp + -510 ]                       <== NOT EXECUTED
4000f0c0:	c2 2f be 03 	stb  %g1, [ %fp + -509 ]                       <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);                         
4000f0c4:	84 10 3f f8 	mov  -8, %g2                                   <== NOT EXECUTED
4000f0c8:	c2 2f be 05 	stb  %g1, [ %fp + -507 ]                       <== NOT EXECUTED
4000f0cc:	c2 2f be 06 	stb  %g1, [ %fp + -506 ]                       <== NOT EXECUTED
4000f0d0:	c4 2f be 04 	stb  %g2, [ %fp + -508 ]                       <== NOT EXECUTED
4000f0d4:	82 10 20 0f 	mov  0xf, %g1                                  <== NOT EXECUTED
4000f0d8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4000f0dc:	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);                         
4000f0e0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
4000f0e4:	84 10 3f f8 	mov  -8, %g2                                   <== NOT EXECUTED
4000f0e8:	c2 2f be 09 	stb  %g1, [ %fp + -503 ]                       <== NOT EXECUTED
4000f0ec:	c2 2f be 0a 	stb  %g1, [ %fp + -502 ]                       <== NOT EXECUTED
4000f0f0:	c4 2f be 08 	stb  %g2, [ %fp + -504 ]                       <== NOT EXECUTED
4000f0f4:	82 10 20 0f 	mov  0xf, %g1                                  <== NOT EXECUTED
4000f0f8:	10 bf ff 35 	b  4000edcc <msdos_format+0x584>               <== NOT EXECUTED
4000f0fc:	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;                                                   
4000f100:	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));                
4000f104:	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)));          
4000f108:	82 10 3f 8f 	mov  -113, %g1                                 <== NOT EXECUTED
4000f10c:	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));                   
4000f110:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
4000f114:	10 bf ff 2e 	b  4000edcc <msdos_format+0x584>               <== NOT EXECUTED
4000f118:	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);                  
4000f11c:	c4 0f bd dd 	ldub  [ %fp + -547 ], %g2                      <== NOT EXECUTED
      FAT_SET_VAL8(tmp_sec,1,0xff);                                   
4000f120:	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);                  
4000f124:	c4 2f be 00 	stb  %g2, [ %fp + -512 ]                       <== NOT EXECUTED
      FAT_SET_VAL8(tmp_sec,1,0xff);                                   
4000f128:	c2 2f be 01 	stb  %g1, [ %fp + -511 ]                       <== NOT EXECUTED
      /* FAT entry 1: EOC */                                          
      FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);                         
4000f12c:	84 10 3f f8 	mov  -8, %g2                                   <== NOT EXECUTED
4000f130:	c2 2f be 03 	stb  %g1, [ %fp + -509 ]                       <== NOT EXECUTED
4000f134:	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;                                                   
4000f138:	10 bf ff 25 	b  4000edcc <msdos_format+0x584>               <== NOT EXECUTED
4000f13c:	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;                                        
4000f140:	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,         
4000f144:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000f148:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000f14c:	94 12 a1 20 	or  %o2, 0x120, %o2                            <== NOT EXECUTED
4000f150:	7f ff fd 03 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000f154:	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) {         
4000f158:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
4000f15c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000f160:	02 80 01 75 	be  4000f734 <msdos_format+0xeec>              <== NOT EXECUTED
4000f164:	07 00 00 1f 	sethi  %hi(0x7c00), %g3                        <== NOT EXECUTED
4000f168:	85 28 60 02 	sll  %g1, 2, %g2                               <== NOT EXECUTED
4000f16c:	87 28 60 0a 	sll  %g1, 0xa, %g3                             <== NOT EXECUTED
4000f170:	86 20 c0 02 	sub  %g3, %g2, %g3                             <== NOT EXECUTED
4000f174:	86 00 c0 01 	add  %g3, %g1, %g3                             <== NOT EXECUTED
4000f178:	87 28 e0 02 	sll  %g3, 2, %g3                               <== NOT EXECUTED
4000f17c:	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) {
4000f180:	c4 07 bd b0 	ld  [ %fp + -592 ], %g2                        <== NOT EXECUTED
4000f184:	80 a0 80 03 	cmp  %g2, %g3                                  <== NOT EXECUTED
4000f188:	1a 80 01 4f 	bcc  4000f6c4 <msdos_format+0xe7c>             <== NOT EXECUTED
4000f18c:	87 28 60 02 	sll  %g1, 2, %g3                               <== NOT EXECUTED
      fmt_params->fattype = FAT_FAT12;                                
4000f190:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4000f194:	c2 2f bd de 	stb  %g1, [ %fp + -546 ]                       <== NOT EXECUTED
      /* start trying with small clusters */                          
      fmt_params->sectors_per_cluster = 2;                            
4000f198:	82 10 20 02 	mov  2, %g1                                    <== NOT EXECUTED
4000f19c:	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 );
4000f1a0:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000f1a4:	7f ff fd 88 	call  4000e7c4 <msdos_set_sectors_per_cluster_from_request><== NOT EXECUTED
4000f1a8:	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                                             
4000f1ac:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000f1b0:	12 80 01 d2 	bne  4000f8f8 <msdos_format+0x10b0>            <== NOT EXECUTED
4000f1b4:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
          && fmt_params->fattype != fat_type                          
4000f1b8:	80 a0 60 ff 	cmp  %g1, 0xff                                 <== NOT EXECUTED
4000f1bc:	02 80 01 d5 	be  4000f910 <msdos_format+0x10c8>             <== NOT EXECUTED
4000f1c0:	c2 07 bd b0 	ld  [ %fp + -592 ], %g1                        <== NOT EXECUTED
          && fmt_params->totl_sector_cnt > 0 ) {                      
4000f1c4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000f1c8:	02 bf ff ab 	be  4000f074 <msdos_format+0x82c>              <== NOT EXECUTED
4000f1cc:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000f1d0:	84 40 20 00 	addx  %g0, 0, %g2                              <== NOT EXECUTED
4000f1d4:	c4 2f bd 57 	stb  %g2, [ %fp + -681 ]                       <== NOT EXECUTED
4000f1d8:	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;                 
4000f1dc:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
4000f1e0:	1b 10 00 00 	sethi  %hi(0x40000000), %o5                    <== NOT EXECUTED
4000f1e4:	86 87 40 0d 	addcc  %i5, %o5, %g3                           <== NOT EXECUTED
4000f1e8:	84 47 00 0c 	addx  %i4, %o4, %g2                            <== NOT EXECUTED
4000f1ec:	a6 10 20 00 	clr  %l3                                       <== NOT EXECUTED
4000f1f0:	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                  
4000f1f4:	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;                 
4000f1f8:	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                  
4000f1fc:	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;                 
4000f200:	84 11 00 02 	or  %g4, %g2, %g2                              <== NOT EXECUTED
4000f204:	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)                             
4000f208:	80 a5 a0 00 	cmp  %l6, 0                                    <== NOT EXECUTED
4000f20c:	02 80 00 05 	be  4000f220 <msdos_format+0x9d8>              <== NOT EXECUTED
4000f210:	d6 07 bd b8 	ld  [ %fp + -584 ], %o3                        <== NOT EXECUTED
        fmt_params->skip_alignment = rqdata->skip_alignment;          
4000f214:	c2 0e 60 16 	ldub  [ %i1 + 0x16 ], %g1                      <== NOT EXECUTED
4000f218:	c2 2f bd fc 	stb  %g1, [ %fp + -516 ]                       <== NOT EXECUTED
                                                                      
      if (ret_val == 0) {                                             
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,     
4000f21c:	d6 07 bd b8 	ld  [ %fp + -584 ], %o3                        <== NOT EXECUTED
4000f220:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000f224:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000f228:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000f22c:	7f ff fc cc 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000f230:	94 12 a1 38 	or  %o2, 0x138, %o2	! 4002dd38 <_CPU_Trap_slot_template+0xd0><== NOT EXECUTED
                             "sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
                                                                      
        if (fmt_params->fattype == FAT_FAT32) {                       
4000f234:	fa 0f bd de 	ldub  [ %fp + -546 ], %i5                      <== NOT EXECUTED
4000f238:	80 a7 60 04 	cmp  %i5, 4                                    <== NOT EXECUTED
4000f23c:	02 80 01 13 	be  4000f688 <msdos_format+0xe40>              <== NOT EXECUTED
4000f240:	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) &&                                     
4000f244:	80 a5 a0 00 	cmp  %l6, 0                                    <== NOT EXECUTED
4000f248:	02 80 01 0a 	be  4000f670 <msdos_format+0xe28>              <== NOT EXECUTED
4000f24c:	c8 27 bd b4 	st  %g4, [ %fp + -588 ]                        <== NOT EXECUTED
              (rqdata->files_per_root_dir > 0)) {                     
4000f250:	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) &&                                     
4000f254:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000f258:	02 80 01 07 	be  4000f674 <msdos_format+0xe2c>              <== NOT EXECUTED
4000f25c:	82 1f 60 02 	xor  %i5, 2, %g1                               <== NOT EXECUTED
4000f260:	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/
4000f264:	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 %
4000f268:	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/
4000f26c:	93 2e e0 01 	sll  %i3, 1, %o1                               <== NOT EXECUTED
4000f270:	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 +
4000f274:	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 %
4000f278:	40 00 6d 20 	call  4002a6f8 <.urem>                         <== NOT EXECUTED
4000f27c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4000f280:	90 27 00 08 	sub  %i4, %o0, %o0                             <== NOT EXECUTED
4000f284:	d0 27 bd c4 	st  %o0, [ %fp + -572 ]                        <== NOT EXECUTED
4000f288:	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);                           
4000f28c:	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)                       
4000f290:	a4 06 ff ff 	add  %i3, -1, %l2                              <== NOT EXECUTED
           / fmt_params->bytes_per_sector);                           
4000f294:	7f ff cc f8 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f298:	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,
4000f29c:	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);                           
4000f2a0:	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 =                                
4000f2a4:	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) {
4000f2a8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000f2ac:	7f ff cc f2 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f2b0:	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,
4000f2b4:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000f2b8:	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) {
4000f2bc:	80 a5 c0 08 	cmp  %l7, %o0                                  <== NOT EXECUTED
4000f2c0:	08 80 00 06 	bleu  4000f2d8 <msdos_format+0xa90>            <== NOT EXECUTED
4000f2c4:	f4 0f bd fc 	ldub  [ %fp + -516 ], %i2                      <== NOT EXECUTED
    sectors_per_cluster /= 2;                                         
4000f2c8:	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) {
4000f2cc:	80 a2 00 17 	cmp  %o0, %l7                                  <== NOT EXECUTED
4000f2d0:	2a bf ff ff 	bcs,a   4000f2cc <msdos_format+0xa84>          <== NOT EXECUTED
4000f2d4:	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);          
4000f2d8:	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                               
4000f2dc:	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);          
4000f2e0:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
4000f2e4:	a2 0c 60 ff 	and  %l1, 0xff, %l1                            <== NOT EXECUTED
4000f2e8:	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                               
4000f2ec:	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);          
4000f2f0:	a8 05 3f ff 	add  %l4, -1, %l4                              <== NOT EXECUTED
4000f2f4:	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)                                               
4000f2f8:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4000f2fc:	02 80 00 0a 	be  4000f324 <msdos_format+0xadc>              <== NOT EXECUTED
4000f300:	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) {                                       
4000f304:	80 a7 60 01 	cmp  %i5, 1                                    <== NOT EXECUTED
4000f308:	02 80 01 8e 	be  4000f940 <msdos_format+0x10f8>             <== NOT EXECUTED
4000f30c:	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) {                                  
4000f310:	80 a7 60 02 	cmp  %i5, 2                                    <== NOT EXECUTED
4000f314:	12 80 00 0c 	bne  4000f344 <msdos_format+0xafc>             <== NOT EXECUTED
4000f318:	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;     
4000f31c:	10 80 00 99 	b  4000f580 <msdos_format+0xd38>               <== NOT EXECUTED
4000f320:	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);          
4000f324:	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) {                                       
4000f328:	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);          
4000f32c:	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) {                                       
4000f330:	02 80 00 86 	be  4000f548 <msdos_format+0xd00>              <== NOT EXECUTED
4000f334:	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) {                                  
4000f338:	80 a7 60 02 	cmp  %i5, 2                                    <== NOT EXECUTED
4000f33c:	02 80 00 8e 	be  4000f574 <msdos_format+0xd2c>              <== NOT EXECUTED
4000f340:	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;     
4000f344:	7f ff cc cc 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f348:	92 10 00 17 	mov  %l7, %o1                                  <== NOT EXECUTED
4000f34c:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
      fat_capacity        = fatdata_cluster_cnt * 4;                  
4000f350:	91 2a 20 02 	sll  %o0, 2, %o0                               <== NOT EXECUTED
    }                                                                 
                                                                      
    sectors_per_fat = ((fat_capacity                                  
4000f354:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000f358:	7f ff cc c7 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f35c:	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,    
4000f360:	7f ff cc 8b 	call  4000258c <.umul>                         <== NOT EXECUTED
4000f364:	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)                                               
4000f368:	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,    
4000f36c:	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)                                               
4000f370:	12 80 00 05 	bne  4000f384 <msdos_format+0xb3c>             <== NOT EXECUTED
4000f374:	90 05 ff ff 	add  %l7, -1, %o0                              <== NOT EXECUTED
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000f378:	82 20 00 17 	neg  %l7, %g1                                  <== NOT EXECUTED
4000f37c:	b8 07 00 08 	add  %i4, %o0, %i4                             <== NOT EXECUTED
4000f380:	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));                                          
4000f384:	90 02 00 1c 	add  %o0, %i4, %o0                             <== NOT EXECUTED
4000f388:	7f ff cc bb 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f38c:	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)) ||
4000f390:	80 a7 60 01 	cmp  %i5, 1                                    <== NOT EXECUTED
4000f394:	02 80 00 54 	be  4000f4e4 <msdos_format+0xc9c>              <== NOT EXECUTED
4000f398:	b0 24 00 08 	sub  %l0, %o0, %i0                             <== NOT EXECUTED
4000f39c:	80 a7 60 02 	cmp  %i5, 2                                    <== NOT EXECUTED
4000f3a0:	02 80 00 62 	be  4000f528 <msdos_format+0xce0>              <== NOT EXECUTED
4000f3a4:	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)               
4000f3a8:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
4000f3ac:	7f ff cc 78 	call  4000258c <.umul>                         <== NOT EXECUTED
4000f3b0:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000f3b4:	07 00 00 20 	sethi  %hi(0x8000), %g3                        <== NOT EXECUTED
4000f3b8:	80 a2 00 03 	cmp  %o0, %g3                                  <== NOT EXECUTED
4000f3bc:	08 80 00 57 	bleu  4000f518 <msdos_format+0xcd0>            <== NOT EXECUTED
4000f3c0:	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;               
4000f3c4:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4000f3c8:	7f ff cc ab 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f3cc:	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 =                       
4000f3d0:	09 10 00 b7 	sethi  %hi(0x4002dc00), %g4                    <== NOT EXECUTED
      finished = true;                                                
    }                                                                 
  } while (!finished);                                                
                                                                      
  *sectors_per_cluster_adj = sectors_per_cluster;                     
  *sectors_per_fat_ptr     = fat_sectors_cnt / fat_num;               
4000f3d4:	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 =                       
4000f3d8:	d0 01 21 f0 	ld  [ %g4 + 0x1f0 ], %o0                       <== NOT EXECUTED
4000f3dc:	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;    
4000f3e0:	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 =                       
4000f3e4:	7f ff cc a4 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f3e8:	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                       
4000f3ec:	80 a2 00 17 	cmp  %o0, %l7                                  <== NOT EXECUTED
4000f3f0:	1a 80 00 69 	bcc  4000f594 <msdos_format+0xd4c>             <== NOT EXECUTED
4000f3f4:	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 =                       
4000f3f8:	03 10 00 b7 	sethi  %hi(0x4002dc00), %g1                    <== NOT EXECUTED
4000f3fc:	d0 00 61 f4 	ld  [ %g1 + 0x1f4 ], %o0	! 4002ddf4 <_CPU_Trap_slot_template+0x18c><== NOT EXECUTED
4000f400:	7f ff cc 9d 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f404:	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                  
4000f408:	80 a2 00 17 	cmp  %o0, %l7                                  <== NOT EXECUTED
4000f40c:	2a 80 00 07 	bcs,a   4000f428 <msdos_format+0xbe0>          <== NOT EXECUTED
4000f410:	84 10 20 04 	mov  4, %g2                                    <== NOT EXECUTED
4000f414:	07 00 00 3f 	sethi  %hi(0xfc00), %g3                        <== NOT EXECUTED
4000f418:	86 10 e3 f4 	or  %g3, 0x3f4, %g3	! fff4 <PROM_START+0xfff4> <== NOT EXECUTED
4000f41c:	80 a0 c0 10 	cmp  %g3, %l0                                  <== NOT EXECUTED
4000f420:	0a 80 00 2f 	bcs  4000f4dc <msdos_format+0xc94>             <== NOT EXECUTED
4000f424:	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) {                      
4000f428:	82 08 a0 ff 	and  %g2, 0xff, %g1                            <== NOT EXECUTED
4000f42c:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
4000f430:	02 80 00 5f 	be  4000f5ac <msdos_format+0xd64>              <== NOT EXECUTED
4000f434:	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 ) {                         
4000f438:	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                             
4000f43c:	82 10 20 1f 	mov  0x1f, %g1                                 <== NOT EXECUTED
4000f440:	84 08 a0 ff 	and  %g2, 0xff, %g2                            <== NOT EXECUTED
4000f444:	80 a0 a0 01 	cmp  %g2, 1                                    <== NOT EXECUTED
4000f448:	18 80 00 06 	bgu  4000f460 <msdos_format+0xc18>             <== NOT EXECUTED
4000f44c:	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;                              
4000f450:	10 80 01 16 	b  4000f8a8 <msdos_format+0x1060>              <== NOT EXECUTED
4000f454:	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-- ) {                                      
4000f458:	02 80 00 07 	be  4000f474 <msdos_format+0xc2c>              <== NOT EXECUTED
4000f45c:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
      if ( (gigs & ( 1 << b) ) != 0 )                                 
4000f460:	88 10 20 01 	mov  1, %g4                                    <== NOT EXECUTED
4000f464:	85 29 00 01 	sll  %g4, %g1, %g2                             <== NOT EXECUTED
4000f468:	80 88 80 03 	btst  %g2, %g3                                 <== NOT EXECUTED
4000f46c:	02 bf ff fb 	be  4000f458 <msdos_format+0xc10>              <== NOT EXECUTED
4000f470:	82 80 7f ff 	addcc  %g1, -1, %g1                            <== NOT EXECUTED
        break;                                                        
    }                                                                 
    fmt_params->sectors_per_cluster = 1 << b;                         
4000f474:	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,
4000f478:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000f47c:	7f ff fc d2 	call  4000e7c4 <msdos_set_sectors_per_cluster_from_request><== NOT EXECUTED
4000f480:	92 07 bd ac 	add  %fp, -596, %o1                            <== NOT EXECUTED
                                                                  fmt_params );
          }                                                           
        }                                                             
        if (fat_type != fmt_params->fattype && 1 < iteration_cnt) {   
4000f484:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
4000f488:	84 08 60 ff 	and  %g1, 0xff, %g2                            <== NOT EXECUTED
4000f48c:	80 a7 40 02 	cmp  %i5, %g2                                  <== NOT EXECUTED
4000f490:	02 80 00 08 	be  4000f4b0 <msdos_format+0xc68>              <== NOT EXECUTED
4000f494:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000f498:	84 0c e0 ff 	and  %l3, 0xff, %g2                            <== NOT EXECUTED
4000f49c:	80 a0 a0 01 	cmp  %g2, 1                                    <== NOT EXECUTED
4000f4a0:	08 80 00 05 	bleu  4000f4b4 <msdos_format+0xc6c>            <== NOT EXECUTED
4000f4a4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
          --fmt_params->totl_sector_cnt;                              
4000f4a8:	aa 05 7f ff 	add  %l5, -1, %l5                              <== NOT EXECUTED
4000f4ac:	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                                             
4000f4b0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000f4b4:	12 80 00 b6 	bne  4000f78c <msdos_format+0xf44>             <== NOT EXECUTED
4000f4b8:	a6 04 e0 01 	inc  %l3                                       <== NOT EXECUTED
          && fmt_params->fattype != fat_type                          
4000f4bc:	82 08 60 ff 	and  %g1, 0xff, %g1                            <== NOT EXECUTED
4000f4c0:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
4000f4c4:	02 80 00 3a 	be  4000f5ac <msdos_format+0xd64>              <== NOT EXECUTED
4000f4c8:	80 a5 60 00 	cmp  %l5, 0                                    <== NOT EXECUTED
          && fmt_params->totl_sector_cnt > 0 ) {                      
4000f4cc:	12 bf ff 50 	bne  4000f20c <msdos_format+0x9c4>             <== NOT EXECUTED
4000f4d0:	80 a5 a0 00 	cmp  %l6, 0                                    <== NOT EXECUTED
4000f4d4:	10 bf fe ea 	b  4000f07c <msdos_format+0x834>               <== NOT EXECUTED
4000f4d8:	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;                                        
4000f4dc:	10 bf ff d3 	b  4000f428 <msdos_format+0xbe0>               <== NOT EXECUTED
4000f4e0:	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)) ||
4000f4e4:	80 a6 2f f5 	cmp  %i0, 0xff5                                <== NOT EXECUTED
4000f4e8:	08 80 00 04 	bleu  4000f4f8 <msdos_format+0xcb0>            <== NOT EXECUTED
4000f4ec:	a0 10 20 01 	mov  1, %l0                                    <== NOT EXECUTED
        ((fattype == FAT_FAT16) && (*data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
      sectors_per_cluster *= 2;                                       
4000f4f0:	af 2d e0 01 	sll  %l7, 1, %l7                               <== NOT EXECUTED
4000f4f4:	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)) {
4000f4f8:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
4000f4fc:	7f ff cc 24 	call  4000258c <.umul>                         <== NOT EXECUTED
4000f500:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4000f504:	05 00 00 04 	sethi  %hi(0x1000), %g2                        <== NOT EXECUTED
4000f508:	80 a2 00 02 	cmp  %o0, %g2                                  <== NOT EXECUTED
4000f50c:	38 bf ff af 	bgu,a   4000f3c8 <msdos_format+0xb80>          <== NOT EXECUTED
4000f510:	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);                                                
4000f514:	80 8c 20 ff 	btst  0xff, %l0                                <== NOT EXECUTED
4000f518:	02 bf ff 79 	be  4000f2fc <msdos_format+0xab4>              <== NOT EXECUTED
4000f51c:	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;               
4000f520:	10 bf ff aa 	b  4000f3c8 <msdos_format+0xb80>               <== NOT EXECUTED
4000f524:	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))) {
4000f528:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        <== NOT EXECUTED
4000f52c:	82 10 63 f5 	or  %g1, 0x3f5, %g1	! fff5 <PROM_START+0xfff5> <== NOT EXECUTED
4000f530:	80 a6 00 01 	cmp  %i0, %g1                                  <== NOT EXECUTED
4000f534:	08 bf ff 9e 	bleu  4000f3ac <msdos_format+0xb64>            <== NOT EXECUTED
4000f538:	90 10 00 17 	mov  %l7, %o0                                  <== NOT EXECUTED
      sectors_per_cluster *= 2;                                       
4000f53c:	af 2d e0 01 	sll  %l7, 1, %l7                               <== NOT EXECUTED
4000f540:	10 bf ff 9a 	b  4000f3a8 <msdos_format+0xb60>               <== NOT EXECUTED
4000f544:	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);          
4000f548:	c6 07 bd 48 	ld  [ %fp + -696 ], %g3                        <== NOT EXECUTED
4000f54c:	84 00 c0 17 	add  %g3, %l7, %g2                             <== NOT EXECUTED
4000f550:	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;     
4000f554:	90 22 00 01 	sub  %o0, %g1, %o0                             <== NOT EXECUTED
4000f558:	7f ff cc 47 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f55c:	92 10 00 17 	mov  %l7, %o1                                  <== NOT EXECUTED
4000f560:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
      fat_capacity        = fatdata_cluster_cnt * 3 / 2;              
4000f564:	91 2a 20 01 	sll  %o0, 1, %o0                               <== NOT EXECUTED
4000f568:	90 02 00 10 	add  %o0, %l0, %o0                             <== NOT EXECUTED
4000f56c:	10 bf ff 7a 	b  4000f354 <msdos_format+0xb0c>               <== NOT EXECUTED
4000f570:	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);          
4000f574:	84 01 00 17 	add  %g4, %l7, %g2                             <== NOT EXECUTED
4000f578:	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;     
4000f57c:	90 22 00 01 	sub  %o0, %g1, %o0                             <== NOT EXECUTED
4000f580:	7f ff cc 3d 	call  40002674 <.udiv>                         <== NOT EXECUTED
4000f584:	92 10 00 17 	mov  %l7, %o1                                  <== NOT EXECUTED
4000f588:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
      fat_capacity        = fatdata_cluster_cnt * 2;                  
4000f58c:	10 bf ff 72 	b  4000f354 <msdos_format+0xb0c>               <== NOT EXECUTED
4000f590:	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                       
4000f594:	18 bf ff 99 	bgu  4000f3f8 <msdos_format+0xbb0>             <== NOT EXECUTED
4000f598:	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) {                      
4000f59c:	82 08 a0 ff 	and  %g2, 0xff, %g1                            <== NOT EXECUTED
4000f5a0:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
4000f5a4:	12 bf ff a5 	bne  4000f438 <msdos_format+0xbf0>             <== NOT EXECUTED
4000f5a8:	c4 2f bd de 	stb  %g2, [ %fp + -546 ]                       <== NOT EXECUTED
4000f5ac:	f6 07 bd 40 	ld  [ %fp + -704 ], %i3                        <== NOT EXECUTED
4000f5b0:	ee 07 bd 3c 	ld  [ %fp + -708 ], %l7                        <== NOT EXECUTED
      }                                                               
                                                                      
      ++iteration_cnt;                                                
    }                                                                 
  }                                                                   
  if ( fmt_params->totl_sector_cnt == 0 )                             
4000f5b4:	80 a5 60 00 	cmp  %l5, 0                                    <== NOT EXECUTED
4000f5b8:	02 bf fe b1 	be  4000f07c <msdos_format+0x834>              <== NOT EXECUTED
4000f5bc:	c2 0f bd de 	ldub  [ %fp + -546 ], %g1                      <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
                                                                      
  if (0 == ret_val)                                                   
  {                                                                   
    if (FAT_FAT32 != fmt_params->fattype)                             
4000f5c0:	80 a0 60 04 	cmp  %g1, 4                                    <== NOT EXECUTED
4000f5c4:	02 80 00 8b 	be  4000f7f0 <msdos_format+0xfa8>              <== NOT EXECUTED
4000f5c8:	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)                                               
4000f5cc:	f8 0f bd fc 	ldub  [ %fp + -516 ], %i4                      <== NOT EXECUTED
4000f5d0:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4000f5d4:	12 80 00 06 	bne  4000f5ec <msdos_format+0xda4>             <== NOT EXECUTED
4000f5d8:	f4 07 bd b8 	ld  [ %fp + -584 ], %i2                        <== NOT EXECUTED
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000f5dc:	90 02 00 1a 	add  %o0, %i2, %o0                             <== NOT EXECUTED
4000f5e0:	82 20 00 1a 	neg  %i2, %g1                                  <== NOT EXECUTED
4000f5e4:	90 02 3f ff 	add  %o0, -1, %o0                              <== NOT EXECUTED
4000f5e8:	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);
4000f5ec:	d2 07 bd ac 	ld  [ %fp + -596 ], %o1                        <== NOT EXECUTED
4000f5f0:	7f ff cb e7 	call  4000258c <.umul>                         <== NOT EXECUTED
4000f5f4:	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,
4000f5f8:	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)                                               
4000f5fc:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4000f600:	12 80 00 06 	bne  4000f618 <msdos_format+0xdd0>             <== NOT EXECUTED
4000f604:	fa 07 bd b4 	ld  [ %fp + -588 ], %i5                        <== NOT EXECUTED
    return (sectors + clustersize - 1) & ~(clustersize - 1);          
4000f608:	ba 07 7f ff 	add  %i5, -1, %i5                              <== NOT EXECUTED
4000f60c:	82 20 00 1a 	neg  %i2, %g1                                  <== NOT EXECUTED
4000f610:	ba 07 40 1a 	add  %i5, %i2, %i5                             <== NOT EXECUTED
4000f614:	ba 0f 40 01 	and  %i5, %g1, %i5                             <== NOT EXECUTED
                                                                      
  /*                                                                  
   * determine media code                                             
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata != NULL) &&                                           
4000f618:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4000f61c:	02 80 00 26 	be  4000f6b4 <msdos_format+0xe6c>              <== NOT EXECUTED
4000f620:	fa 27 bd b4 	st  %i5, [ %fp + -588 ]                        <== NOT EXECUTED
	(rqdata->media != 0)) {                                              
4000f624:	f8 0e 60 14 	ldub  [ %i1 + 0x14 ], %i4                      <== NOT EXECUTED
                                                                      
  /*                                                                  
   * determine media code                                             
   */                                                                 
  if (ret_val == 0) {                                                 
    if ((rqdata != NULL) &&                                           
4000f628:	b4 8f 20 ff 	andcc  %i4, 0xff, %i2                          <== NOT EXECUTED
4000f62c:	02 80 00 23 	be  4000f6b8 <msdos_format+0xe70>              <== NOT EXECUTED
4000f630:	82 10 3f f8 	mov  -8, %g1                                   <== NOT EXECUTED
	(rqdata->media != 0)) {                                              
      const char valid_media_codes[] =                                
4000f634:	94 10 20 09 	mov  9, %o2                                    <== NOT EXECUTED
4000f638:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
4000f63c:	13 10 00 b7 	sethi  %hi(0x4002dc00), %o1                    <== NOT EXECUTED
4000f640:	40 00 3a 79 	call  4001e024 <memcpy>                        <== NOT EXECUTED
4000f644:	92 12 61 e0 	or  %o1, 0x1e0, %o1	! 4002dde0 <_CPU_Trap_slot_template+0x178><== NOT EXECUTED
	{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};                      
      if (NULL==memchr(valid_media_codes,                             
4000f648:	90 07 be 00 	add  %fp, -512, %o0                            <== NOT EXECUTED
4000f64c:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4000f650:	40 00 3a 07 	call  4001de6c <memchr>                        <== NOT EXECUTED
4000f654:	94 10 20 09 	mov  9, %o2                                    <== NOT EXECUTED
4000f658:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000f65c:	02 80 00 b2 	be  4000f924 <msdos_format+0x10dc>             <== NOT EXECUTED
4000f660:	01 00 00 00 	nop                                            <== NOT EXECUTED
		       sizeof(valid_media_codes))) {                                
	ret_val = -1;                                                        
	errno = EINVAL;                                                      
      }                                                               
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
4000f664:	f8 2f bd dd 	stb  %i4, [ %fp + -547 ]                       <== NOT EXECUTED
4000f668:	10 bf fc c3 	b  4000e974 <msdos_format+0x12c>               <== NOT EXECUTED
4000f66c:	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) {                   
4000f670:	82 1f 60 02 	xor  %i5, 2, %g1                               <== NOT EXECUTED
4000f674:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
4000f678:	90 40 3f ff 	addx  %g0, -1, %o0                             <== NOT EXECUTED
4000f67c:	90 0a 21 c0 	and  %o0, 0x1c0, %o0                           <== NOT EXECUTED
4000f680:	10 bf fe f9 	b  4000f264 <msdos_format+0xa1c>               <== NOT EXECUTED
4000f684:	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;                           
4000f688:	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;                               
4000f68c:	84 10 20 06 	mov  6, %g2                                    <== NOT EXECUTED
          /* location of fsinfo sector */                             
          fmt_params->fsinfo_sec = 1;                                 
4000f690:	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;                           
4000f694:	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;                         
4000f698:	c0 27 bd c4 	clr  [ %fp + -572 ]                            <== NOT EXECUTED
          /* location of copy of MBR */                               
          fmt_params->mbr_copy_sec = 6;                               
4000f69c:	c4 27 bd d4 	st  %g2, [ %fp + -556 ]                        <== NOT EXECUTED
          /* location of fsinfo sector */                             
          fmt_params->fsinfo_sec = 1;                                 
4000f6a0:	c6 27 bd d8 	st  %g3, [ %fp + -552 ]                        <== NOT EXECUTED
4000f6a4:	f6 07 bd ac 	ld  [ %fp + -596 ], %i3                        <== NOT EXECUTED
4000f6a8:	a8 10 20 20 	mov  0x20, %l4                                 <== NOT EXECUTED
4000f6ac:	10 bf fe f8 	b  4000f28c <msdos_format+0xa44>               <== NOT EXECUTED
4000f6b0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
      else {                                                          
	fmt_params->media_code = rqdata->media;                              
      }                                                               
    }                                                                 
    else {                                                            
      fmt_params->media_code = FAT_BR_MEDIA_FIXED;                    
4000f6b4:	82 10 3f f8 	mov  -8, %g1                                   <== NOT EXECUTED
4000f6b8:	f8 0f bd 57 	ldub  [ %fp + -681 ], %i4                      <== NOT EXECUTED
4000f6bc:	10 bf fc ae 	b  4000e974 <msdos_format+0x12c>               <== NOT EXECUTED
4000f6c0:	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) {
4000f6c4:	89 28 60 0e 	sll  %g1, 0xe, %g4                             <== NOT EXECUTED
4000f6c8:	86 21 00 03 	sub  %g4, %g3, %g3                             <== NOT EXECUTED
4000f6cc:	86 00 c0 01 	add  %g3, %g1, %g3                             <== NOT EXECUTED
4000f6d0:	87 28 e0 02 	sll  %g3, 2, %g3                               <== NOT EXECUTED
4000f6d4:	82 00 c0 01 	add  %g3, %g1, %g1                             <== NOT EXECUTED
4000f6d8:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
4000f6dc:	2a 80 00 1f 	bcs,a   4000f758 <msdos_format+0xf10>          <== NOT EXECUTED
4000f6e0:	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;                                
4000f6e4:	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;                 
4000f6e8:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
4000f6ec:	1b 10 00 00 	sethi  %hi(0x40000000), %o5                    <== NOT EXECUTED
4000f6f0:	86 87 40 0d 	addcc  %i5, %o5, %g3                           <== NOT EXECUTED
4000f6f4:	84 47 00 0c 	addx  %i4, %o4, %g2                            <== NOT EXECUTED
      int b;                                                          
      fmt_params->fattype = FAT_FAT32;                                
4000f6f8:	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;                 
4000f6fc:	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--)                                        
4000f700:	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;                 
4000f704:	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)                                   
4000f708:	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;                 
4000f70c:	10 80 00 04 	b  4000f71c <msdos_format+0xed4>               <== NOT EXECUTED
4000f710:	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--)                                        
4000f714:	02 80 00 67 	be  4000f8b0 <msdos_format+0x1068>             <== NOT EXECUTED
4000f718:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
        if ((gigs & (1 << b)) != 0)                                   
4000f71c:	85 28 c0 01 	sll  %g3, %g1, %g2                             <== NOT EXECUTED
4000f720:	80 88 80 04 	btst  %g2, %g4                                 <== NOT EXECUTED
4000f724:	02 bf ff fc 	be  4000f714 <msdos_format+0xecc>              <== NOT EXECUTED
4000f728:	82 80 7f ff 	addcc  %g1, -1, %g1                            <== NOT EXECUTED
          break;                                                      
      fmt_params->sectors_per_cluster = 1 << b;                       
4000f72c:	10 bf fe 9d 	b  4000f1a0 <msdos_format+0x958>               <== NOT EXECUTED
4000f730:	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;                               
4000f734:	82 10 20 20 	mov  0x20, %g1                                 <== NOT EXECUTED
                                                                      
    if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {         
4000f738:	10 bf fe 92 	b  4000f180 <msdos_format+0x938>               <== NOT EXECUTED
4000f73c:	86 10 e3 a8 	or  %g3, 0x3a8, %g3                            <== NOT EXECUTED
4000f740:	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) {                        
4000f744:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
4000f748:	a4 10 20 00 	clr  %l2                                       <== NOT EXECUTED
4000f74c:	a6 10 20 00 	clr  %l3                                       <== NOT EXECUTED
4000f750:	10 bf fd 0c 	b  4000eb80 <msdos_format+0x338>               <== NOT EXECUTED
4000f754:	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;                                
4000f758:	c2 2f bd de 	stb  %g1, [ %fp + -546 ]                       <== NOT EXECUTED
      /* start trying with small clusters */                          
      fmt_params->sectors_per_cluster = 2;                            
4000f75c:	82 10 20 02 	mov  2, %g1                                    <== NOT EXECUTED
4000f760:	10 bf fe 90 	b  4000f1a0 <msdos_format+0x958>               <== NOT EXECUTED
4000f764:	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;                                                 
4000f768:	40 00 37 8a 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000f76c:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000f770:	82 10 20 16 	mov  0x16, %g1	! 16 <PROM_START+0x16>          <== NOT EXECUTED
      ret_val = -1;                                                   
4000f774:	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;                                                 
4000f778:	10 bf fc 75 	b  4000e94c <msdos_format+0x104>               <== NOT EXECUTED
4000f77c:	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),                           
4000f780:	03 10 00 b7 	sethi  %hi(0x4002dc00), %g1                    <== NOT EXECUTED
4000f784:	10 bf fd 3f 	b  4000ec80 <msdos_format+0x438>               <== NOT EXECUTED
4000f788:	82 10 60 a8 	or  %g1, 0xa8, %g1	! 4002dca8 <_CPU_Trap_slot_template+0x40><== NOT EXECUTED
4000f78c:	f6 07 bd 40 	ld  [ %fp + -704 ], %i3                        <== NOT EXECUTED
4000f790:	10 bf fc 73 	b  4000e95c <msdos_format+0x114>               <== NOT EXECUTED
4000f794:	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();                                              
4000f798:	40 00 3c df 	call  4001eb14 <rand>                          <== NOT EXECUTED
4000f79c:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000f7a0:	10 bf fc c5 	b  4000eab4 <msdos_format+0x26c>               <== NOT EXECUTED
4000f7a4:	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,       
4000f7a8:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4000f7ac:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000f7b0:	7f ff fb 6b 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000f7b4:	94 12 a1 88 	or  %o2, 0x188, %o2	! 4002dd88 <_CPU_Trap_slot_template+0x120><== NOT EXECUTED
                           "write back up MRB sector\n");             
      ret_val = msdos_format_write_sec(fd,                            
4000f7b8:	d2 07 bd d4 	ld  [ %fp + -556 ], %o1                        <== NOT EXECUTED
4000f7bc:	d4 07 bd ac 	ld  [ %fp + -596 ], %o2                        <== NOT EXECUTED
4000f7c0:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000f7c4:	7f ff fb 7b 	call  4000e5b0 <msdos_format_write_sec>        <== NOT EXECUTED
4000f7c8:	96 07 be 00 	add  %fp, -512, %o3                            <== NOT EXECUTED
    }                                                                 
  }                                                                   
  /*                                                                  
   * for FAT32: initialize info sector on disk                        
   */                                                                 
  if ((ret_val == 0) &&                                               
4000f7cc:	ae 92 20 00 	orcc  %o0, 0, %l7                              <== NOT EXECUTED
4000f7d0:	02 bf fd 4f 	be  4000ed0c <msdos_format+0x4c4>              <== NOT EXECUTED
4000f7d4:	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) {                                                     
4000f7d8:	10 bf fc 4c 	b  4000e908 <msdos_format+0xc0>                <== NOT EXECUTED
4000f7dc:	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 */     
4000f7e0:	10 bf fc 79 	b  4000e9c4 <msdos_format+0x17c>               <== NOT EXECUTED
4000f7e4:	88 11 20 c8 	or  %g4, 0xc8, %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 */     
4000f7e8:	10 bf fc 97 	b  4000ea44 <msdos_format+0x1fc>               <== NOT EXECUTED
4000f7ec:	88 11 21 50 	or  %g4, 0x150, %g4                            <== NOT EXECUTED
4000f7f0:	f4 07 bd b8 	ld  [ %fp + -584 ], %i2                        <== NOT EXECUTED
4000f7f4:	10 bf ff 82 	b  4000f5fc <msdos_format+0xdb4>               <== NOT EXECUTED
4000f7f8:	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); 
4000f7fc:	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 */
4000f800:	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); 
4000f804:	b1 30 60 08 	srl  %g1, 8, %i0                               <== NOT EXECUTED
4000f808:	bb 30 60 10 	srl  %g1, 0x10, %i5                            <== NOT EXECUTED
4000f80c:	89 30 60 18 	srl  %g1, 0x18, %g4                            <== NOT EXECUTED
4000f810:	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);      
4000f814:	82 10 20 29 	mov  0x29, %g1                                 <== NOT EXECUTED
4000f818:	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),                     
4000f81c:	03 00 00 11 	sethi  %hi(0x4400), %g1                        <== NOT EXECUTED
4000f820:	82 10 62 41 	or  %g1, 0x241, %g1	! 4641 <PROM_START+0x4641> <== NOT EXECUTED
4000f824:	c2 37 be 52 	sth  %g1, [ %fp + -430 ]                       <== NOT EXECUTED
4000f828:	03 00 00 15 	sethi  %hi(0x5400), %g1                        <== NOT EXECUTED
4000f82c:	82 10 60 33 	or  %g1, 0x33, %g1	! 5433 <PROM_START+0x5433>  <== NOT EXECUTED
4000f830:	c2 37 be 54 	sth  %g1, [ %fp + -428 ]                       <== NOT EXECUTED
4000f834:	03 00 00 0c 	sethi  %hi(0x3000), %g1                        <== NOT EXECUTED
4000f838:	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 */
4000f83c:	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),                     
4000f840:	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); 
4000f844:	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),                     
4000f848:	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); 
4000f84c:	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),                     
4000f850:	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); 
4000f854:	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 */
4000f858:	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*/
4000f85c:	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 */
4000f860:	c4 2f be 32 	stb  %g2, [ %fp + -462 ]                       <== NOT EXECUTED
4000f864:	c6 2f be 33 	stb  %g3, [ %fp + -461 ]                       <== NOT EXECUTED
    memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
4000f868:	c0 27 be 34 	clr  [ %fp + -460 ]                            <== NOT EXECUTED
4000f86c:	c0 27 be 38 	clr  [ %fp + -456 ]                            <== NOT EXECUTED
4000f870:	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);
4000f874:	c0 2f be 47 	clrb  [ %fp + -441 ]                           <== NOT EXECUTED
4000f878:	c0 2f be 48 	clrb  [ %fp + -440 ]                           <== NOT EXECUTED
4000f87c:	c0 2f be 49 	clrb  [ %fp + -439 ]                           <== NOT EXECUTED
4000f880:	c0 2f be 4a 	clrb  [ %fp + -438 ]                           <== NOT EXECUTED
4000f884:	c0 2f be 4b 	clrb  [ %fp + -437 ]                           <== NOT EXECUTED
4000f888:	c0 2f be 4c 	clrb  [ %fp + -436 ]                           <== NOT EXECUTED
4000f88c:	c0 2f be 4d 	clrb  [ %fp + -435 ]                           <== NOT EXECUTED
4000f890:	c0 2f be 4e 	clrb  [ %fp + -434 ]                           <== NOT EXECUTED
4000f894:	c0 2f be 4f 	clrb  [ %fp + -433 ]                           <== NOT EXECUTED
4000f898:	c0 2f be 50 	clrb  [ %fp + -432 ]                           <== NOT EXECUTED
4000f89c:	c0 2f be 51 	clrb  [ %fp + -431 ]                           <== NOT EXECUTED
    memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),                     
4000f8a0:	10 bf fd 00 	b  4000eca0 <msdos_format+0x458>               <== NOT EXECUTED
4000f8a4:	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;                              
4000f8a8:	10 bf fe f4 	b  4000f478 <msdos_format+0xc30>               <== NOT EXECUTED
4000f8ac:	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;                       
4000f8b0:	10 bf fe 3c 	b  4000f1a0 <msdos_format+0x958>               <== NOT EXECUTED
4000f8b4:	c4 27 bd b8 	st  %g2, [ %fp + -584 ]                        <== NOT EXECUTED
4000f8b8:	c6 0f bd 57 	ldub  [ %fp + -681 ], %g3                      <== NOT EXECUTED
4000f8bc:	80 a0 00 08 	cmp  %g0, %o0                                  <== NOT EXECUTED
4000f8c0:	82 60 3f ff 	subx  %g0, -1, %g1                             <== NOT EXECUTED
4000f8c4:	10 bf fd 66 	b  4000ee5c <msdos_format+0x614>               <== NOT EXECUTED
4000f8c8:	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,         
4000f8cc:	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;                                        
4000f8d0:	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,         
4000f8d4:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000f8d8:	96 10 20 02 	mov  2, %o3                                    <== NOT EXECUTED
4000f8dc:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000f8e0:	7f ff fb 1f 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000f8e4:	94 12 a1 20 	or  %o2, 0x120, %o2	! 4002dd20 <_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;                              
4000f8e8:	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;                               
4000f8ec:	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;                              
4000f8f0:	10 bf fe 24 	b  4000f180 <msdos_format+0x938>               <== NOT EXECUTED
4000f8f4:	86 10 e3 a8 	or  %g3, 0x3a8, %g3                            <== NOT EXECUTED
4000f8f8:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000f8fc:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000f900:	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                                             
4000f904:	84 10 00 17 	mov  %l7, %g2                                  <== NOT EXECUTED
4000f908:	10 bf fc 15 	b  4000e95c <msdos_format+0x114>               <== NOT EXECUTED
4000f90c:	c2 2f bd 57 	stb  %g1, [ %fp + -681 ]                       <== NOT EXECUTED
4000f910:	80 a0 00 19 	cmp  %g0, %i1                                  <== NOT EXECUTED
4000f914:	ea 07 bd b0 	ld  [ %fp + -592 ], %l5                        <== NOT EXECUTED
4000f918:	82 40 20 00 	addx  %g0, 0, %g1                              <== NOT EXECUTED
4000f91c:	10 bf ff 26 	b  4000f5b4 <msdos_format+0xd6c>               <== NOT EXECUTED
4000f920:	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;                                                      
4000f924:	40 00 37 1b 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000f928:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
4000f92c:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4000f930:	fa 07 bd b4 	ld  [ %fp + -588 ], %i5                        <== NOT EXECUTED
4000f934:	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;                                                        
4000f938:	10 bf fc 0f 	b  4000e974 <msdos_format+0x12c>               <== NOT EXECUTED
4000f93c:	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;                                                   
4000f940:	10 bf ff 05 	b  4000f554 <msdos_format+0xd0c>               <== NOT EXECUTED
4000f944:	c2 07 bd 4c 	ld  [ %fp + -692 ], %g1                        <== NOT EXECUTED
                                                                      

4000e610 <msdos_format_fill_sectors>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
4000e610:	9d e3 bf a0 	save  %sp, -96, %sp                            
                                                                      
  /*                                                                  
   * allocate and fill buffer                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    fill_buffer = malloc(sector_size);                                
4000e614:	90 10 00 1c 	mov  %i4, %o0                                  
4000e618:	7f ff df 30 	call  400062d8 <malloc>                        
4000e61c:	a6 10 00 18 	mov  %i0, %l3                                  
    if (fill_buffer == NULL) {                                        
4000e620:	80 a2 20 00 	cmp  %o0, 0                                    
4000e624:	02 80 00 47 	be  4000e740 <msdos_format_fill_sectors+0x130> <== NEVER TAKEN
4000e628:	a4 10 00 08 	mov  %o0, %l2                                  
      errno = ENOMEM;                                                 
      ret_val = -1;                                                   
    }                                                                 
    else {                                                            
      memset(fill_buffer,fill_byte,sector_size);                      
4000e62c:	92 10 00 1d 	mov  %i5, %o1                                  
4000e630:	40 00 3e ba 	call  4001e118 <memset>                        
4000e634:	94 10 00 1c 	mov  %i4, %o2                                  
    }                                                                 
  }                                                                   
                                                                      
  msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,           
4000e638:	90 10 00 18 	mov  %i0, %o0                                  
4000e63c:	92 10 20 02 	mov  2, %o1                                    
4000e640:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    
4000e644:	7f ff ff c6 	call  4000e55c <msdos_format_printf>           
4000e648:	94 12 a0 78 	or  %o2, 0x78, %o2	! 4002dc78 <_CPU_Trap_slot_template+0x10>
                       "Filling : ");                                 
  /*                                                                  
   * write to consecutive sectors                                     
   */                                                                 
  while ((ret_val == 0) &&                                            
4000e64c:	80 a6 e0 00 	cmp  %i3, 0                                    
4000e650:	02 80 00 56 	be  4000e7a8 <msdos_format_fill_sectors+0x198> <== NEVER TAKEN
4000e654:	83 2e e0 04 	sll  %i3, 4, %g1                               
4000e658:	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, ".");
4000e65c:	29 10 00 b6 	sethi  %hi(0x4002d800), %l4                    
4000e660:	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) &&                                            
4000e664:	a0 10 00 1b 	mov  %i3, %l0                                  
4000e668:	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;                                              
4000e66c:	a2 10 3f ff 	mov  -1, %l1                                   
4000e670:	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, ".");
4000e674:	10 80 00 10 	b  4000e6b4 <msdos_format_fill_sectors+0xa4>   
4000e678:	a8 15 20 80 	or  %l4, 0x80, %l4                             
      last_percent = percent;                                         
    }                                                                 
    ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000e67c:	92 10 00 1a 	mov  %i2, %o1                                  
4000e680:	90 10 00 19 	mov  %i1, %o0                                  
4000e684:	94 10 00 1c 	mov  %i4, %o2                                  
4000e688:	96 10 00 12 	mov  %l2, %o3                                  
4000e68c:	7f ff ff c9 	call  4000e5b0 <msdos_format_write_sec>        
4000e690:	a0 04 3f ff 	add  %l0, -1, %l0                              
    start_sector++;                                                   
4000e694:	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);
4000e698:	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) &&                                            
4000e69c:	80 a2 20 00 	cmp  %o0, 0                                    
4000e6a0:	12 80 00 1c 	bne  4000e710 <msdos_format_fill_sectors+0x100><== NEVER TAKEN
4000e6a4:	ba 07 7f 9c 	add  %i5, -100, %i5                            
4000e6a8:	80 a4 20 00 	cmp  %l0, 0                                    
4000e6ac:	02 80 00 1a 	be  4000e714 <msdos_format_fill_sectors+0x104> 
4000e6b0:	90 10 00 13 	mov  %l3, %o0                                  
	 (sector_cnt > 0)) {                                                 
    int percent = (sector_cnt * 100) / total_sectors;                 
4000e6b4:	92 10 00 1b 	mov  %i3, %o1                                  
4000e6b8:	7f ff cf ef 	call  40002674 <.udiv>                         
4000e6bc:	90 10 00 1d 	mov  %i5, %o0                                  
    if (percent != last_percent) {                                    
4000e6c0:	80 a2 00 11 	cmp  %o0, %l1                                  
4000e6c4:	02 bf ff ee 	be  4000e67c <msdos_format_fill_sectors+0x6c>  
4000e6c8:	80 8a 20 01 	btst  1, %o0                                   
      if ((percent & 1) == 0)                                         
4000e6cc:	12 bf ff ec 	bne  4000e67c <msdos_format_fill_sectors+0x6c> 
4000e6d0:	a2 10 00 08 	mov  %o0, %l1                                  
        msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
4000e6d4:	90 10 00 13 	mov  %l3, %o0                                  
4000e6d8:	92 10 20 02 	mov  2, %o1                                    
4000e6dc:	7f ff ff a0 	call  4000e55c <msdos_format_printf>           
4000e6e0:	94 10 00 14 	mov  %l4, %o2                                  
      last_percent = percent;                                         
    }                                                                 
    ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
4000e6e4:	92 10 00 1a 	mov  %i2, %o1                                  
4000e6e8:	90 10 00 19 	mov  %i1, %o0                                  
4000e6ec:	94 10 00 1c 	mov  %i4, %o2                                  
4000e6f0:	96 10 00 12 	mov  %l2, %o3                                  
4000e6f4:	7f ff ff af 	call  4000e5b0 <msdos_format_write_sec>        
4000e6f8:	a0 04 3f ff 	add  %l0, -1, %l0                              
    start_sector++;                                                   
4000e6fc:	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);
4000e700:	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) &&                                            
4000e704:	80 a2 20 00 	cmp  %o0, 0                                    
4000e708:	02 bf ff e8 	be  4000e6a8 <msdos_format_fill_sectors+0x98>  <== ALWAYS TAKEN
4000e70c:	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");    
4000e710:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
4000e714:	92 10 20 02 	mov  2, %o1                                    
4000e718:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    
4000e71c:	7f ff ff 90 	call  4000e55c <msdos_format_printf>           
4000e720:	94 12 a1 80 	or  %o2, 0x180, %o2	! 4002dd80 <_CPU_Trap_slot_template+0x118>
                                                                      
  if (ret_val)                                                        
4000e724:	80 a6 20 00 	cmp  %i0, 0                                    
4000e728:	12 80 00 16 	bne  4000e780 <msdos_format_fill_sectors+0x170><== NEVER TAKEN
4000e72c:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
  /*                                                                  
   * cleanup                                                          
   */                                                                 
  if (fill_buffer != NULL) {                                          
    free(fill_buffer);                                                
4000e730:	7f ff dd 97 	call  40005d8c <free>                          
4000e734:	90 10 00 12 	mov  %l2, %o0                                  
4000e738:	81 c7 e0 08 	ret                                            
4000e73c:	81 e8 00 00 	restore                                        
   * allocate and fill buffer                                         
   */                                                                 
  if (ret_val == 0) {                                                 
    fill_buffer = malloc(sector_size);                                
    if (fill_buffer == NULL) {                                        
      errno = ENOMEM;                                                 
4000e740:	40 00 3b 94 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000e744:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000e748:	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,           
4000e74c:	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;                                                 
4000e750:	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,           
4000e754:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000e758:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000e75c:	7f ff ff 80 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000e760:	94 12 a0 78 	or  %o2, 0x78, %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");    
4000e764:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000e768:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000e76c:	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;                                                   
4000e770:	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");    
4000e774:	7f ff ff 7a 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000e778:	94 12 a1 80 	or  %o2, 0x180, %o2                            <== NOT EXECUTED
                                                                      
  if (ret_val)                                                        
    msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,           
4000e77c:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
4000e780:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4000e784:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
4000e788:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000e78c:	7f ff ff 74 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000e790:	94 12 a0 88 	or  %o2, 0x88, %o2	! 4002dc88 <_CPU_Trap_slot_template+0x20><== NOT EXECUTED
                         "filling error on sector: %d\n", start_sector);
                                                                      
  /*                                                                  
   * cleanup                                                          
   */                                                                 
  if (fill_buffer != NULL) {                                          
4000e794:	80 a4 a0 00 	cmp  %l2, 0                                    <== NOT EXECUTED
4000e798:	12 bf ff e6 	bne  4000e730 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
4000e79c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    free(fill_buffer);                                                
    fill_buffer = NULL;                                               
  }                                                                   
  return ret_val;                                                     
}                                                                     
4000e7a0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e7a4:	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");    
4000e7a8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000e7ac:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value:                                                             |
|    0, if success, -1 and errno if failed                                  |
\*=========================================================================*/
{                                                                     
  int ret_val = 0;                                                    
4000e7b0:	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");    
4000e7b4:	15 10 00 b7 	sethi  %hi(0x4002dc00), %o2                    <== NOT EXECUTED
4000e7b8:	7f ff ff 69 	call  4000e55c <msdos_format_printf>           <== NOT EXECUTED
4000e7bc:	94 12 a1 80 	or  %o2, 0x180, %o2	! 4002dd80 <_CPU_Trap_slot_template+0x118><== NOT EXECUTED
4000e7c0:	30 bf ff dc 	b,a   4000e730 <msdos_format_fill_sectors+0x120><== NOT EXECUTED
                                                                      

4000e55c <msdos_format_printf>: */ static void msdos_format_printf (const msdos_format_request_param_t *rqdata, int info_level, const char *format, ...) {
4000e55c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  va_list args;                                                       
  va_start (args, format);                                            
4000e560:	94 07 a0 50 	add  %fp, 0x50, %o2                            
4000e564:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
4000e568:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
4000e56c:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
  if (rqdata != NULL && rqdata->info_level >= info_level)             
4000e570:	80 a6 20 00 	cmp  %i0, 0                                    
4000e574:	02 80 00 0d 	be  4000e5a8 <msdos_format_printf+0x4c>        
4000e578:	d4 27 bf fc 	st  %o2, [ %fp + -4 ]                          
4000e57c:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
4000e580:	80 a0 40 19 	cmp  %g1, %i1                                  
4000e584:	06 80 00 09 	bl  4000e5a8 <msdos_format_printf+0x4c>        <== ALWAYS TAKEN
4000e588:	3b 10 00 bb 	sethi  %hi(0x4002ec00), %i5                    
  {                                                                   
    vfprintf (stdout, format, args);                                  
4000e58c:	c2 07 61 50 	ld  [ %i5 + 0x150 ], %g1	! 4002ed50 <_impure_ptr><== NOT EXECUTED
4000e590:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4000e594:	40 00 5d 0c 	call  400259c4 <vfprintf>                      <== NOT EXECUTED
4000e598:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
    fflush (stdout);                                                  
4000e59c:	c2 07 61 50 	ld  [ %i5 + 0x150 ], %g1                       <== NOT EXECUTED
4000e5a0:	40 00 3c ff 	call  4001d99c <fflush>                        <== NOT EXECUTED
4000e5a4:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
4000e5a8:	81 c7 e0 08 	ret                                            
4000e5ac:	81 e8 00 00 	restore                                        
                                                                      

4000e5b0 <msdos_format_write_sec>: ) /*-------------------------------------------------------------------------*\ | Return Value: | | 0, if success, -1 and errno if failed | \*=========================================================================*/ {
4000e5b0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int ret_val = 0;                                                    
                                                                      
  if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {     
4000e5b4:	94 10 20 00 	clr  %o2                                       
4000e5b8:	96 10 00 1a 	mov  %i2, %o3                                  
4000e5bc:	90 10 20 00 	clr  %o0                                       
4000e5c0:	7f ff ce d6 	call  40002118 <__muldi3>                      
4000e5c4:	92 10 00 19 	mov  %i1, %o1                                  
4000e5c8:	84 10 00 08 	mov  %o0, %g2                                  
4000e5cc:	86 10 00 09 	mov  %o1, %g3                                  
4000e5d0:	90 10 00 18 	mov  %i0, %o0                                  
4000e5d4:	92 10 00 02 	mov  %g2, %o1                                  
4000e5d8:	94 10 00 03 	mov  %g3, %o2                                  
4000e5dc:	40 00 1f 49 	call  40016300 <lseek>                         
4000e5e0:	96 10 20 00 	clr  %o3                                       
4000e5e4:	80 a2 20 00 	cmp  %o0, 0                                    
4000e5e8:	16 80 00 04 	bge  4000e5f8 <msdos_format_write_sec+0x48>    <== ALWAYS TAKEN
4000e5ec:	90 10 00 18 	mov  %i0, %o0                                  
4000e5f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e5f4:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
    ret_val = -1;                                                     
  }                                                                   
  if (ret_val == 0) {                                                 
    if (0 > write(fd,buffer,sector_size)) {                           
4000e5f8:	92 10 00 1b 	mov  %i3, %o1                                  
4000e5fc:	7f ff ee 0f 	call  40009e38 <write>                         
4000e600:	94 10 00 1a 	mov  %i2, %o2                                  
4000e604:	b1 3a 20 1f 	sra  %o0, 0x1f, %i0                            
      ret_val = -1;                                                   
    }                                                                 
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
4000e608:	81 c7 e0 08 	ret                                            
4000e60c:	81 e8 00 00 	restore                                        
                                                                      

4001aba4 <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 ) {
4001aba4:	9d e3 bf 50 	save  %sp, -176, %sp                           
    int              rc = RC_OK;                                      
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
4001aba8:	f8 06 20 08 	ld  [ %i0 + 8 ], %i4                           
    fat_file_fd_t   *fat_fd = NULL;                                   
4001abac:	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);              
4001abb0:	90 10 00 1c 	mov  %i4, %o0                                  
4001abb4:	92 10 00 1a 	mov  %i2, %o1                                  
4001abb8:	7f ff e2 bc 	call  400136a8 <fat_file_open>                 
4001abbc:	94 07 bf bc 	add  %fp, -68, %o2                             
    if (rc != RC_OK)                                                  
4001abc0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001abc4:	02 80 00 04 	be  4001abd4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x30><== ALWAYS TAKEN
4001abc8:	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;                                                        
}                                                                     
4001abcc:	81 c7 e0 08 	ret                                            
4001abd0:	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;                        
4001abd4:	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;                                                
4001abd8:	f2 22 60 1c 	st  %i1, [ %o1 + 0x1c ]                        
    fat_fd->fat_file_type = FAT_DIRECTORY;                            
4001abdc:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
4001abe0:	c4 22 60 14 	st  %g2, [ %o1 + 0x14 ]                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
4001abe4:	c0 22 60 34 	clr  [ %o1 + 0x34 ]                            
    fat_fd->map.disk_cln = fat_fd->cln;                               
4001abe8:	f2 22 60 38 	st  %i1, [ %o1 + 0x38 ]                        
                                                                      
    rc = fat_file_size(&fs_info->fat, fat_fd);                        
4001abec:	7f ff e5 e5 	call  40014380 <fat_file_size>                 
4001abf0:	90 10 00 1c 	mov  %i4, %o0                                  
    if (rc != RC_OK)                                                  
4001abf4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001abf8:	12 80 00 95 	bne  4001ae4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
4001abfc:	33 10 00 b6 	sethi  %hi(0x4002d800), %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);           
4001ac00:	ba 07 bf c0 	add  %fp, -64, %i5                             
    msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);      
4001ac04:	94 10 00 1d 	mov  %i5, %o2                                  
4001ac08:	92 10 20 01 	mov  1, %o1                                    
4001ac0c:	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);           
4001ac10:	c0 27 bf c0 	clr  [ %fp + -64 ]                             
4001ac14:	c0 27 bf c4 	clr  [ %fp + -60 ]                             
4001ac18:	c0 27 bf c8 	clr  [ %fp + -56 ]                             
4001ac1c:	c0 27 bf cc 	clr  [ %fp + -52 ]                             
4001ac20:	c0 27 bf d0 	clr  [ %fp + -48 ]                             
4001ac24:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
4001ac28:	c0 27 bf d8 	clr  [ %fp + -40 ]                             
4001ac2c:	c0 27 bf dc 	clr  [ %fp + -36 ]                             
    msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);      
4001ac30:	7f ff fa eb 	call  400197dc <msdos_long_to_short>           
4001ac34:	90 16 60 80 	or  %i1, 0x80, %o0                             
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1, 
4001ac38:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
4001ac3c:	fa 23 a0 60 	st  %i5, [ %sp + 0x60 ]                        
4001ac40:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        
4001ac44:	90 10 00 18 	mov  %i0, %o0                                  
4001ac48:	94 10 20 00 	clr  %o2                                       
4001ac4c:	96 16 60 80 	or  %i1, 0x80, %o3                             
4001ac50:	98 10 20 01 	mov  1, %o4                                    
4001ac54:	7f ff fc da 	call  40019fbc <msdos_find_name_in_fat_file>   
4001ac58:	9a 10 20 01 	mov  1, %o5                                    
                                     MSDOS_NAME_SHORT, dir_pos, dot_node);
                                                                      
    if (rc != RC_OK)                                                  
4001ac5c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001ac60:	12 80 00 7b 	bne  4001ae4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a8><== NEVER TAKEN
4001ac64:	33 10 00 b8 	sethi  %hi(0x4002e000), %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);        
4001ac68:	ba 07 bf e0 	add  %fp, -32, %i5                             
    msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);  
4001ac6c:	94 10 00 1d 	mov  %i5, %o2                                  
4001ac70:	92 10 20 02 	mov  2, %o1                                    
4001ac74:	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);        
4001ac78:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
4001ac7c:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
4001ac80:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
4001ac84:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
4001ac88:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
4001ac8c:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
4001ac90:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
4001ac94:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);  
4001ac98:	7f ff fa d1 	call  400197dc <msdos_long_to_short>           
4001ac9c:	90 16 60 a8 	or  %i1, 0xa8, %o0                             
    rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
4001aca0:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
4001aca4:	fa 23 a0 60 	st  %i5, [ %sp + 0x60 ]                        
4001aca8:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        
4001acac:	90 10 00 18 	mov  %i0, %o0                                  
4001acb0:	94 10 20 00 	clr  %o2                                       
4001acb4:	96 16 60 a8 	or  %i1, 0xa8, %o3                             
4001acb8:	98 10 20 02 	mov  2, %o4                                    
4001acbc:	7f ff fc c0 	call  40019fbc <msdos_find_name_in_fat_file>   
4001acc0:	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);                        
4001acc4:	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)                                                  
4001acc8:	80 a2 20 00 	cmp  %o0, 0                                    
4001accc:	12 80 00 66 	bne  4001ae64 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
4001acd0:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
4001acd4:	f2 17 bf da 	lduh  [ %fp + -38 ], %i1                       
4001acd8:	e0 17 bf d4 	lduh  [ %fp + -44 ], %l0                       
                                                                      
    /* close fat-file corresponded to ".." directory */               
    rc = fat_file_close(&fs_info->fat, fat_fd);                       
4001acdc:	7f ff e3 ed 	call  40013c90 <fat_file_close>                
4001ace0:	90 10 00 1c 	mov  %i4, %o0                                  
    if ( rc != RC_OK )                                                
4001ace4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001ace8:	12 bf ff b9 	bne  4001abcc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
4001acec:	c4 17 bf fa 	lduh  [ %fp + -6 ], %g2                        
        return rc;                                                    
                                                                      
    if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)               
4001acf0:	c6 17 bf f4 	lduh  [ %fp + -12 ], %g3                       
4001acf4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
4001acf8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001acfc:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
4001ad00:	bb 30 e0 18 	srl  %g3, 0x18, %i5                            
4001ad04:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
4001ad08:	87 30 e0 08 	srl  %g3, 8, %g3                               
4001ad0c:	82 10 63 ff 	or  %g1, 0x3ff, %g1                            
4001ad10:	85 30 a0 08 	srl  %g2, 8, %g2                               
4001ad14:	86 08 c0 01 	and  %g3, %g1, %g3                             
4001ad18:	82 08 80 01 	and  %g2, %g1, %g1                             
4001ad1c:	86 17 40 03 	or  %i5, %g3, %g3                              
4001ad20:	82 11 00 01 	or  %g4, %g1, %g1                              
4001ad24:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001ad28:	80 90 c0 01 	orcc  %g3, %g1, %g0                            
4001ad2c:	12 80 00 08 	bne  4001ad4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1a8><== ALWAYS TAKEN
4001ad30:	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;                           
4001ad34:	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;                                             
4001ad38:	c0 26 a0 04 	clr  [ %i2 + 4 ]                               <== NOT EXECUTED
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
4001ad3c:	c2 26 a0 08 	st  %g1, [ %i2 + 8 ]                           <== NOT EXECUTED
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
4001ad40:	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;                 
4001ad44:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4001ad48:	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);              
4001ad4c:	92 10 00 1a 	mov  %i2, %o1                                  
4001ad50:	7f ff e2 56 	call  400136a8 <fat_file_open>                 
4001ad54:	94 07 bf bc 	add  %fp, -68, %o2                             
    if (rc != RC_OK)                                                  
4001ad58:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001ad5c:	12 bf ff 9c 	bne  4001abcc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28><== NEVER TAKEN
4001ad60:	c2 17 bf f4 	lduh  [ %fp + -12 ], %g1                       
        return rc;                                                    
                                                                      
    if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)                
4001ad64:	c8 17 bf fa 	lduh  [ %fp + -6 ], %g4                        
4001ad68:	83 28 60 10 	sll  %g1, 0x10, %g1                            
4001ad6c:	07 00 00 3f 	sethi  %hi(0xfc00), %g3                        
4001ad70:	85 30 60 18 	srl  %g1, 0x18, %g2                            
4001ad74:	86 10 e3 ff 	or  %g3, 0x3ff, %g3                            
4001ad78:	83 30 60 08 	srl  %g1, 8, %g1                               
4001ad7c:	82 08 40 03 	and  %g1, %g3, %g1                             
4001ad80:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001ad84:	84 10 80 01 	or  %g2, %g1, %g2                              
4001ad88:	bb 31 20 18 	srl  %g4, 0x18, %i5                            
4001ad8c:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
4001ad90:	89 31 20 08 	srl  %g4, 8, %g4                               
4001ad94:	86 09 00 03 	and  %g4, %g3, %g3                             
4001ad98:	82 17 40 03 	or  %i5, %g3, %g1                              
4001ad9c:	82 90 80 01 	orcc  %g2, %g1, %g1                            
4001ada0:	12 80 00 35 	bne  4001ae74 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d0><== ALWAYS TAKEN
4001ada4:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         
        fat_fd->cln = fs_info->fat.vol.rdir_cl;                       
4001ada8:	c2 07 20 3c 	ld  [ %i4 + 0x3c ], %g1                        <== NOT EXECUTED
4001adac:	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;                               
4001adb0:	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;                        
4001adb4:	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;                            
4001adb8:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
4001adbc:	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;                        
4001adc0:	c4 22 60 14 	st  %g2, [ %o1 + 0x14 ]                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
    fat_fd->map.disk_cln = fat_fd->cln;                               
4001adc4:	c2 22 60 38 	st  %g1, [ %o1 + 0x38 ]                        
                                                                      
    rc = fat_file_size(&fs_info->fat, fat_fd);                        
4001adc8:	7f ff e5 6e 	call  40014380 <fat_file_size>                 
4001adcc:	90 10 00 1c 	mov  %i4, %o0                                  
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
4001add0:	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)                                                  
4001add4:	80 a2 20 00 	cmp  %o0, 0                                    
4001add8:	12 80 00 23 	bne  4001ae64 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2c0><== NEVER TAKEN
4001addc:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
4001ade0:	a1 2c 20 10 	sll  %l0, 0x10, %l0                            
4001ade4:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
4001ade8:	95 34 20 18 	srl  %l0, 0x18, %o2                            
4001adec:	85 36 60 18 	srl  %i1, 0x18, %g2                            
4001adf0:	a1 34 20 08 	srl  %l0, 8, %l0                               
4001adf4:	b3 36 60 08 	srl  %i1, 8, %i1                               
4001adf8:	03 00 00 3f 	sethi  %hi(0xfc00), %g1                        
4001adfc:	82 10 63 ff 	or  %g1, 0x3ff, %g1	! ffff <PROM_START+0xffff> 
4001ae00:	a0 0c 00 01 	and  %l0, %g1, %l0                             
4001ae04:	82 0e 40 01 	and  %i1, %g1, %g1                             
4001ae08:	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,
4001ae0c:	90 10 00 18 	mov  %i0, %o0                                  
4001ae10:	96 10 00 1a 	mov  %i2, %o3                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
4001ae14:	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,
4001ae18:	98 10 00 1b 	mov  %i3, %o4                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
        return rc;                                                    
    }                                                                 
                                                                      
    cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);                    
4001ae1c:	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,
4001ae20:	7f ff fe fe 	call  4001aa18 <msdos_find_node_by_cluster_num_in_fat_file>
4001ae24:	94 12 80 01 	or  %o2, %g1, %o2                              
                                                    dir_pos, dir_entry);
    if (rc != RC_OK)                                                  
    {                                                                 
        fat_file_close(&fs_info->fat, fat_fd);                        
4001ae28:	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,
4001ae2c:	ba 10 00 08 	mov  %o0, %i5                                  
                                                    dir_pos, dir_entry);
    if (rc != RC_OK)                                                  
4001ae30:	80 a7 60 00 	cmp  %i5, 0                                    
4001ae34:	12 80 00 12 	bne  4001ae7c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2d8><== NEVER TAKEN
4001ae38:	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);                       
4001ae3c:	7f ff e3 95 	call  40013c90 <fat_file_close>                
4001ae40:	01 00 00 00 	nop                                            
4001ae44:	10 bf ff 62 	b  4001abcc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x28>
4001ae48:	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);                        
4001ae4c:	d2 07 bf bc 	ld  [ %fp + -68 ], %o1                         <== NOT EXECUTED
4001ae50:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4001ae54:	7f ff e3 8f 	call  40013c90 <fat_file_close>                <== NOT EXECUTED
4001ae58:	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;                                                        
}                                                                     
4001ae5c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ae60:	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);                        
4001ae64:	7f ff e3 8b 	call  40013c90 <fat_file_close>                <== NOT EXECUTED
4001ae68:	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;                                                        
}                                                                     
4001ae6c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ae70:	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);         
4001ae74:	10 bf ff cf 	b  4001adb0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c>
4001ae78:	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);                        
4001ae7c:	7f ff e3 85 	call  40013c90 <fat_file_close>                <== NOT EXECUTED
4001ae80:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
4001ae84:	30 bf ff f6 	b,a   4001ae5c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b8><== NOT EXECUTED
                                                                      

4001ae88 <msdos_get_name_node>: int name_len, msdos_name_type_t name_type, fat_dir_pos_t *dir_pos, char *name_dir_entry ) {
4001ae88:	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,    
4001ae8c:	d0 06 20 14 	ld  [ %i0 + 0x14 ], %o0                        
4001ae90:	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            
    )                                                                 
{                                                                     
4001ae94:	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,    
4001ae98:	9a 10 00 1c 	mov  %i4, %o5                                  
4001ae9c:	e0 23 a0 60 	st  %l0, [ %sp + 0x60 ]                        
4001aea0:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
4001aea4:	94 10 00 19 	mov  %i1, %o2                                  
4001aea8:	96 10 00 1a 	mov  %i2, %o3                                  
4001aeac:	7f ff fc 44 	call  40019fbc <msdos_find_name_in_fat_file>   
4001aeb0:	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))            
4001aeb4:	03 00 00 1f 	sethi  %hi(0x7c00), %g1                        
4001aeb8:	82 10 61 01 	or  %g1, 0x101, %g1	! 7d01 <PROM_START+0x7d01> 
4001aebc:	80 a2 00 01 	cmp  %o0, %g1                                  
4001aec0:	12 80 00 2a 	bne  4001af68 <msdos_get_name_node+0xe0>       
4001aec4:	b8 10 00 08 	mov  %o0, %i4                                  
        return rc;                                                    
                                                                      
    if (!create_node)                                                 
4001aec8:	80 a6 60 00 	cmp  %i1, 0                                    
4001aecc:	12 80 00 25 	bne  4001af60 <msdos_get_name_node+0xd8>       
4001aed0:	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)                           
4001aed4:	82 10 61 01 	or  %g1, 0x101, %g1	! 7d01 <PROM_START+0x7d01> 
4001aed8:	80 a7 00 01 	cmp  %i4, %g1                                  
4001aedc:	02 80 00 21 	be  4001af60 <msdos_get_name_node+0xd8>        
4001aee0:	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)                                              
4001aee4:	12 80 00 1f 	bne  4001af60 <msdos_get_name_node+0xd8>       <== NEVER TAKEN
4001aee8:	90 10 00 1a 	mov  %i2, %o0                                  
        {                                                             
            if (strncmp(name, "..", 2) == 0)                          
4001aeec:	94 10 20 02 	mov  2, %o2                                    
4001aef0:	13 10 00 b8 	sethi  %hi(0x4002e000), %o1                    
4001aef4:	40 00 10 9c 	call  4001f164 <strncmp>                       
4001aef8:	92 12 60 a8 	or  %o1, 0xa8, %o1	! 4002e0a8 <IMFS_memfile_handlers+0x44>
4001aefc:	80 a2 20 00 	cmp  %o0, 0                                    
4001af00:	12 80 00 18 	bne  4001af60 <msdos_get_name_node+0xd8>       
4001af04:	05 00 00 3f 	sethi  %hi(0xfc00), %g2                        
            {                                                         
                dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
4001af08:	c2 14 20 14 	lduh  [ %l0 + 0x14 ], %g1                      
4001af0c:	c6 14 20 1a 	lduh  [ %l0 + 0x1a ], %g3                      
4001af10:	83 28 60 10 	sll  %g1, 0x10, %g1                            
4001af14:	b3 30 60 18 	srl  %g1, 0x18, %i1                            
4001af18:	84 10 a3 ff 	or  %g2, 0x3ff, %g2                            
4001af1c:	83 30 60 08 	srl  %g1, 8, %g1                               
4001af20:	82 08 40 02 	and  %g1, %g2, %g1                             
4001af24:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001af28:	b2 16 40 01 	or  %i1, %g1, %i1                              
4001af2c:	89 30 e0 18 	srl  %g3, 0x18, %g4                            
4001af30:	b3 2e 60 10 	sll  %i1, 0x10, %i1                            
4001af34:	87 30 e0 08 	srl  %g3, 8, %g3                               
4001af38:	84 08 c0 02 	and  %g3, %g2, %g2                             
4001af3c:	82 11 00 02 	or  %g4, %g2, %g1                              
                                                                      
                /* are we right under root dir ? */                   
                if (dotdot_cln == 0)                                  
4001af40:	b2 96 40 01 	orcc  %i1, %g1, %i1                            
4001af44:	12 80 00 0e 	bne  4001af7c <msdos_get_name_node+0xf4>       
4001af48:	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;                                             
4001af4c:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
  dir_pos->lname.cln = FAT_FILE_SHORT_NAME;                           
4001af50:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
4001af54:	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;     
4001af58:	82 10 20 01 	mov  1, %g1                                    
4001af5c:	c2 27 40 00 	st  %g1, [ %i5 ]                               
                }                                                     
            }                                                         
        }                                                             
    }                                                                 
    return rc;                                                        
}                                                                     
4001af60:	81 c7 e0 08 	ret                                            
4001af64:	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))            
4001af68:	80 a2 20 00 	cmp  %o0, 0                                    
4001af6c:	02 bf ff d8 	be  4001aecc <msdos_get_name_node+0x44>        
4001af70:	80 a6 60 00 	cmp  %i1, 0                                    
                }                                                     
            }                                                         
        }                                                             
    }                                                                 
    return rc;                                                        
}                                                                     
4001af74:	81 c7 e0 08 	ret                                            
4001af78:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
                    fat_dir_pos_init(dir_pos);                        
                    dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;     
                }                                                     
                else                                                  
                {                                                     
                    rc =                                              
4001af7c:	f0 06 20 14 	ld  [ %i0 + 0x14 ], %i0                        
4001af80:	b4 10 00 1d 	mov  %i5, %i2                                  
4001af84:	7f ff ff 08 	call  4001aba4 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
4001af88:	97 e8 00 10 	restore  %g0, %l0, %o3                         
                                                                      

4000f9e4 <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 ) {
4000f9e4:	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));  
4000f9e8:	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;                                 
4000f9ec:	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));  
4000f9f0:	7f ff d8 b0 	call  40005cb0 <calloc>                        
4000f9f4:	92 10 20 a4 	mov  0xa4, %o1                                 
    if (!fs_info)                                                     
4000f9f8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000f9fc:	02 80 00 58 	be  4000fb5c <msdos_initialize_support+0x178>  <== NEVER TAKEN
4000fa00:	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);     
4000fa04:	d2 06 20 38 	ld  [ %i0 + 0x38 ], %o1                        
4000fa08:	40 00 14 42 	call  40014b10 <fat_init_volume_info>          
4000fa0c:	fa 26 20 08 	st  %i5, [ %i0 + 8 ]                           
    if (rc != RC_OK)                                                  
4000fa10:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4000fa14:	12 80 00 34 	bne  4000fae4 <msdos_initialize_support+0x100> <== NEVER TAKEN
4000fa18:	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;                           
4000fa1c:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;                           
4000fa20:	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;                     
4000fa24:	82 10 20 01 	mov  1, %g1                                    
    {                                                                 
        free(fs_info);                                                
        return rc;                                                    
    }                                                                 
                                                                      
    fs_info->file_handlers      = file_handlers;                      
4000fa28:	f4 27 60 98 	st  %i2, [ %i5 + 0x98 ]                        
    fs_info->directory_handlers = directory_handlers;                 
4000fa2c:	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;                                             
4000fa30:	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);            
4000fa34:	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;                     
4000fa38:	c2 27 bf f0 	st  %g1, [ %fp + -16 ]                         
    rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);            
4000fa3c:	92 07 bf f0 	add  %fp, -16, %o1                             
4000fa40:	40 00 0f 1a 	call  400136a8 <fat_file_open>                 
4000fa44:	94 07 bf ec 	add  %fp, -20, %o2                             
    if (rc != RC_OK)                                                  
4000fa48:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4000fa4c:	12 80 00 24 	bne  4000fadc <msdos_initialize_support+0xf8>  <== NEVER TAKEN
4000fa50:	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;                           
4000fa54:	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;                        
4000fa58:	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;                            
4000fa5c:	c0 22 60 10 	clr  [ %o1 + 0x10 ]                            
    fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;                        
4000fa60:	c4 22 60 14 	st  %g2, [ %o1 + 0x14 ]                        
    fat_fd->cln = fs_info->fat.vol.rdir_cl;                           
4000fa64:	c2 22 60 1c 	st  %g1, [ %o1 + 0x1c ]                        
                                                                      
    fat_fd->map.file_cln = 0;                                         
4000fa68:	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 )                                           
4000fa6c:	80 a0 60 00 	cmp  %g1, 0                                    
4000fa70:	12 80 00 24 	bne  4000fb00 <msdos_initialize_support+0x11c> 
4000fa74:	c2 22 60 38 	st  %g1, [ %o1 + 0x38 ]                        
    {                                                                 
        fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;           
4000fa78:	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                                :
4000fa7c:	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) ?
4000fa80:	80 a2 00 01 	cmp  %o0, %g1                                  
4000fa84:	0a 80 00 1d 	bcs  4000faf8 <msdos_initialize_support+0x114> 
4000fa88:	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));   
4000fa8c:	7f ff d8 89 	call  40005cb0 <calloc>                        
4000fa90:	92 10 20 01 	mov  1, %o1                                    
    if (fs_info->cl_buf == NULL)                                      
4000fa94:	80 a2 20 00 	cmp  %o0, 0                                    
4000fa98:	02 80 00 2a 	be  4000fb40 <msdos_initialize_support+0x15c>  <== NEVER TAKEN
4000fa9c:	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,                                    
4000faa0:	90 10 20 03 	mov  3, %o0                                    
4000faa4:	92 10 20 01 	mov  1, %o1                                    
4000faa8:	94 10 20 10 	mov  0x10, %o2                                 
4000faac:	96 10 20 00 	clr  %o3                                       
4000fab0:	7f ff ea 2a 	call  4000a358 <rtems_semaphore_create>        
4000fab4:	98 07 60 9c 	add  %i5, 0x9c, %o4                            
                                1,                                    
                                RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,  
                                0,                                    
                                &fs_info->vol_sema);                  
    if (sc != RTEMS_SUCCESSFUL)                                       
4000fab8:	80 a2 20 00 	cmp  %o0, 0                                    
4000fabc:	12 80 00 2d 	bne  4000fb70 <msdos_initialize_support+0x18c> <== NEVER TAKEN
4000fac0:	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;         
4000fac4:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
    temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
4000fac8:	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;         
4000facc:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
    temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
    temp_mt_entry->ops = op_table;                                    
4000fad0:	f2 26 20 0c 	st  %i1, [ %i0 + 0xc ]                         
                                                                      
    return rc;                                                        
}                                                                     
4000fad4:	81 c7 e0 08 	ret                                            
4000fad8:	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);                            
4000fadc:	40 00 16 5c 	call  4001544c <fat_shutdown_drive>            <== NOT EXECUTED
4000fae0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        free(fs_info);                                                
4000fae4:	7f ff d8 aa 	call  40005d8c <free>                          <== NOT EXECUTED
4000fae8:	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;                                                        
}                                                                     
4000faec:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4000faf0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000faf4:	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) ?
4000faf8:	10 bf ff e5 	b  4000fa8c <msdos_initialize_support+0xa8>    
4000fafc:	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);                    
4000fb00:	40 00 12 20 	call  40014380 <fat_file_size>                 
4000fb04:	90 10 00 1d 	mov  %i5, %o0                                  
        if ( rc != RC_OK )                                            
4000fb08:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000fb0c:	12 80 00 04 	bne  4000fb1c <msdos_initialize_support+0x138> <== NEVER TAKEN
4000fb10:	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;                           
4000fb14:	10 bf ff de 	b  4000fa8c <msdos_initialize_support+0xa8>    
4000fb18:	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);                                            
4000fb1c:	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);                    
4000fb20:	40 00 10 5c 	call  40013c90 <fat_file_close>                <== NOT EXECUTED
4000fb24:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            fat_shutdown_drive(&fs_info->fat);                        
4000fb28:	40 00 16 49 	call  4001544c <fat_shutdown_drive>            <== NOT EXECUTED
4000fb2c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            free(fs_info);                                            
4000fb30:	7f ff d8 97 	call  40005d8c <free>                          <== NOT EXECUTED
4000fb34:	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;                                                        
}                                                                     
4000fb38:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fb3c:	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);                        
4000fb40:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         <== NOT EXECUTED
4000fb44:	40 00 10 53 	call  40013c90 <fat_file_close>                <== NOT EXECUTED
4000fb48:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        fat_shutdown_drive(&fs_info->fat);                            
4000fb4c:	40 00 16 40 	call  4001544c <fat_shutdown_drive>            <== NOT EXECUTED
4000fb50:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        free(fs_info);                                                
4000fb54:	7f ff d8 8e 	call  40005d8c <free>                          <== NOT EXECUTED
4000fb58:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one(ENOMEM);                 
4000fb5c:	40 00 36 8d 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000fb60:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
4000fb64:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
4000fb68:	10 bf ff e1 	b  4000faec <msdos_initialize_support+0x108>   <== NOT EXECUTED
4000fb6c:	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);                        
4000fb70:	d2 07 bf ec 	ld  [ %fp + -20 ], %o1                         <== NOT EXECUTED
4000fb74:	40 00 10 47 	call  40013c90 <fat_file_close>                <== NOT EXECUTED
4000fb78:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        fat_shutdown_drive(&fs_info->fat);                            
4000fb7c:	40 00 16 34 	call  4001544c <fat_shutdown_drive>            <== NOT EXECUTED
4000fb80:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        free(fs_info->cl_buf);                                        
4000fb84:	d0 07 60 a0 	ld  [ %i5 + 0xa0 ], %o0                        <== NOT EXECUTED
4000fb88:	7f ff d8 81 	call  40005d8c <free>                          <== NOT EXECUTED
4000fb8c:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
        free(fs_info);                                                
4000fb90:	7f ff d8 7f 	call  40005d8c <free>                          <== NOT EXECUTED
4000fb94:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
        rtems_set_errno_and_return_minus_one( EIO );                  
4000fb98:	40 00 36 7e 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000fb9c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4000fba0:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4000fba4:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000fba8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fbac:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000f9ac <msdos_lock>: .rename_h = msdos_rename, .statvfs_h = rtems_filesystem_default_statvfs }; void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry) {
4000f9ac:	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,                                                
4000f9b0:	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(                      
4000f9b4:	92 10 20 00 	clr  %o1                                       
4000f9b8:	d0 00 60 9c 	ld  [ %g1 + 0x9c ], %o0                        
4000f9bc:	7f ff eb 0f 	call  4000a5f8 <rtems_semaphore_obtain>        
4000f9c0:	94 10 20 00 	clr  %o2                                       
    fs_info->vol_sema,                                                
    RTEMS_WAIT,                                                       
    RTEMS_NO_TIMEOUT                                                  
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000f9c4:	80 a2 20 00 	cmp  %o0, 0                                    
4000f9c8:	12 80 00 04 	bne  4000f9d8 <msdos_lock+0x2c>                <== NEVER TAKEN
4000f9cc:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
4000f9d0:	81 c7 e0 08 	ret                                            
4000f9d4:	81 e8 00 00 	restore                                        
    rtems_fatal_error_occurred(0xdeadbeef);                           
4000f9d8:	7f ff ec e9 	call  4000ad7c <rtems_fatal_error_occurred>    <== NOT EXECUTED
4000f9dc:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

400197dc <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) {
400197dc:	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);                                       
400197e0:	92 10 20 20 	mov  0x20, %o1                                 
400197e4:	90 10 00 1a 	mov  %i2, %o0                                  
400197e8:	40 00 12 4c 	call  4001e118 <memset>                        
400197ec:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
    /*                                                                
     * Handle '.' and '..' specially.                                 
     */                                                               
    if ((lfn[0] == '.') && (lfn_len == 1))                            
400197f0:	f8 0e 00 00 	ldub  [ %i0 ], %i4                             
400197f4:	85 2f 20 18 	sll  %i4, 0x18, %g2                            
400197f8:	83 38 a0 18 	sra  %g2, 0x18, %g1                            
400197fc:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40019800:	02 80 00 17 	be  4001985c <msdos_long_to_short+0x80>        
40019804:	a0 10 00 18 	mov  %i0, %l0                                  
    }                                                                 
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
40019808:	80 a6 60 00 	cmp  %i1, 0                                    
4001980c:	04 80 00 70 	ble  400199cc <msdos_long_to_short+0x1f0>      <== NEVER TAKEN
40019810:	83 38 a0 18 	sra  %g2, 0x18, %g1                            
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
40019814:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40019818:	12 80 00 1f 	bne  40019894 <msdos_long_to_short+0xb8>       <== ALWAYS TAKEN
4001981c:	80 a0 60 20 	cmp  %g1, 0x20                                 
40019820:	10 80 00 05 	b  40019834 <msdos_long_to_short+0x58>         <== NOT EXECUTED
40019824:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
40019828:	80 a0 e0 2e 	cmp  %g3, 0x2e                                 
4001982c:	12 80 00 08 	bne  4001984c <msdos_long_to_short+0x70>       <== ALWAYS TAKEN
40019830:	80 a0 e0 20 	cmp  %g3, 0x20                                 
    }                                                                 
                                                                      
    /*                                                                
     * Filenames with only blanks and dots are not allowed!           
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
40019834:	82 00 60 01 	inc  %g1                                       
40019838:	80 a0 40 19 	cmp  %g1, %i1                                  
4001983c:	32 bf ff fb 	bne,a   40019828 <msdos_long_to_short+0x4c>    <== ALWAYS TAKEN
40019840:	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;                                    
40019844:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40019848:	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] != '.'))                       
4001984c:	02 bf ff fb 	be  40019838 <msdos_long_to_short+0x5c>        <== NEVER TAKEN
40019850:	82 00 60 01 	inc  %g1                                       
    bool lowercase = false;                                           
    bool uppercase = false;                                           
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
40019854:	10 80 00 13 	b  400198a0 <msdos_long_to_short+0xc4>         
40019858:	80 a0 a0 00 	cmp  %g2, 0                                    
    memset (sfn, ' ', sfn_len);                                       
                                                                      
    /*                                                                
     * Handle '.' and '..' specially.                                 
     */                                                               
    if ((lfn[0] == '.') && (lfn_len == 1))                            
4001985c:	80 a6 60 01 	cmp  %i1, 1                                    
40019860:	22 80 00 0b 	be,a   4001988c <msdos_long_to_short+0xb0>     
40019864:	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))         
40019868:	c2 4e 20 01 	ldsb  [ %i0 + 1 ], %g1                         
4001986c:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40019870:	12 bf ff e7 	bne  4001980c <msdos_long_to_short+0x30>       <== NEVER TAKEN
40019874:	80 a6 60 00 	cmp  %i1, 0                                    
40019878:	80 a6 60 02 	cmp  %i1, 2                                    
4001987c:	12 bf ff e4 	bne  4001980c <msdos_long_to_short+0x30>       <== NEVER TAKEN
40019880:	80 a6 60 00 	cmp  %i1, 0                                    
    {                                                                 
        sfn[0] = sfn[1] = '.';                                        
40019884:	c2 2e a0 01 	stb  %g1, [ %i2 + 1 ]                          
40019888:	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;                                      
4001988c:	81 c7 e0 08 	ret                                            
40019890:	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] != '.'))                       
40019894:	02 bf ff e8 	be  40019834 <msdos_long_to_short+0x58>        
40019898:	82 10 20 00 	clr  %g1                                       
    bool lowercase = false;                                           
    bool uppercase = false;                                           
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
4001989c:	80 a0 a0 00 	cmp  %g2, 0                                    
400198a0:	02 80 00 44 	be  400199b0 <msdos_long_to_short+0x1d4>       <== NEVER TAKEN
400198a4:	03 10 00 bb 	sethi  %hi(0x4002ec00), %g1                    
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
400198a8:	e8 00 61 48 	ld  [ %g1 + 0x148 ], %l4	! 4002ed48 <__ctype_ptr__>
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
400198ac:	31 10 00 b8 	sethi  %hi(0x4002e000), %i0                    
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
400198b0:	2b 10 00 b8 	sethi  %hi(0x4002e000), %l5                    
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
400198b4:	a4 10 20 00 	clr  %l2                                       
400198b8:	a6 10 20 00 	clr  %l3                                       
400198bc:	ba 10 20 00 	clr  %i5                                       
400198c0:	a2 10 3f ff 	mov  -1, %l1                                   
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
400198c4:	b0 16 22 d8 	or  %i0, 0x2d8, %i0                            
        return MSDOS_NAME_LONG;                                       
                                                                      
    if ((ch == '.') || isalnum((unsigned char)ch) ||                  
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
400198c8:	aa 15 62 e0 	or  %l5, 0x2e0, %l5                            
 *                                                                    
 */                                                                   
static msdos_name_type_t                                              
msdos_is_valid_name_char(const char ch)                               
{                                                                     
    if (strchr(" +,;=[]", ch) != NULL)                                
400198cc:	b7 38 a0 18 	sra  %g2, 0x18, %i3                            
400198d0:	90 10 00 18 	mov  %i0, %o0                                  
400198d4:	40 00 15 55 	call  4001ee28 <strchr>                        
400198d8:	92 10 00 1b 	mov  %i3, %o1                                  
400198dc:	80 a2 20 00 	cmp  %o0, 0                                    
400198e0:	02 80 00 09 	be  40019904 <msdos_long_to_short+0x128>       
400198e4:	82 1e e0 2e 	xor  %i3, 0x2e, %g1                            
        return MSDOS_NAME_LONG;                                       
400198e8:	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);                      
400198ec:	90 10 00 10 	mov  %l0, %o0                                  
400198f0:	92 10 00 19 	mov  %i1, %o1                                  
400198f4:	40 00 0b c1 	call  4001c7f8 <msdos_filename_unix2dos>       
400198f8:	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;                                                      
400198fc:	81 c7 e0 08 	ret                                            
40019900:	81 e8 00 00 	restore                                        
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
    {                                                                 
        bool is_dot = *name == '.';                                   
40019904:	80 a0 00 01 	cmp  %g0, %g1                                  
40019908:	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) ||                  
4001990c:	80 a5 a0 00 	cmp  %l6, 0                                    
40019910:	12 80 00 3c 	bne  40019a00 <msdos_long_to_short+0x224>      
40019914:	82 0f 20 ff 	and  %i4, 0xff, %g1                            
40019918:	82 05 00 01 	add  %l4, %g1, %g1                             
4001991c:	c2 08 60 01 	ldub  [ %g1 + 1 ], %g1                         
40019920:	80 88 60 07 	btst  7, %g1                                   
40019924:	12 80 00 07 	bne  40019940 <msdos_long_to_short+0x164>      
40019928:	90 10 00 15 	mov  %l5, %o0                                  
        (strchr("$%'-_@~`!(){}^#&", ch) != NULL))                     
4001992c:	40 00 15 3f 	call  4001ee28 <strchr>                        
40019930:	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) ||                  
40019934:	80 a2 20 00 	cmp  %o0, 0                                    
40019938:	02 bf ff c3 	be  40019844 <msdos_long_to_short+0x68>        <== NEVER TAKEN
4001993c:	01 00 00 00 	nop                                            
#endif                                                                
                                                                      
        if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
            return type;                                              
                                                                      
        if (dot_at >= 0)                                              
40019940:	80 a4 7f ff 	cmp  %l1, -1                                   
40019944:	02 80 00 27 	be  400199e0 <msdos_long_to_short+0x204>       
40019948:	82 27 40 11 	sub  %i5, %l1, %g1                             
        {                                                             
            if (is_dot || ((count - dot_at) > 3))                     
4001994c:	80 a0 60 03 	cmp  %g1, 3                                    
40019950:	34 bf ff e7 	bg,a   400198ec <msdos_long_to_short+0x110>    <== NEVER TAKEN
40019954:	b0 10 20 02 	mov  2, %i0                                    <== NOT EXECUTED
            }                                                         
        }                                                             
                                                                      
        if (is_dot)                                                   
            dot_at = count;                                           
        else if ((*name >= 'A') && (*name <= 'Z'))                    
40019958:	82 07 3f bf 	add  %i4, -65, %g1                             
4001995c:	82 08 60 ff 	and  %g1, 0xff, %g1                            
40019960:	80 a0 60 19 	cmp  %g1, 0x19                                 
40019964:	28 80 00 07 	bleu,a   40019980 <msdos_long_to_short+0x1a4>  
40019968:	a4 10 20 01 	mov  1, %l2                                    
            uppercase = true;                                         
        else if ((*name >= 'a') && (*name <= 'z'))                    
4001996c:	b8 07 3f 9f 	add  %i4, -97, %i4                             
40019970:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            
40019974:	80 a7 20 19 	cmp  %i4, 0x19                                 
40019978:	28 80 00 02 	bleu,a   40019980 <msdos_long_to_short+0x1a4>  
4001997c:	a6 10 20 01 	mov  1, %l3                                    
            lowercase = true;                                         
                                                                      
        count++;                                                      
40019980:	ba 07 60 01 	inc  %i5                                       
    bool lowercase = false;                                           
    bool uppercase = false;                                           
    int  dot_at = -1;                                                 
    int  count = 0;                                                   
                                                                      
    while (*name && (count < name_len))                               
40019984:	f8 0c 00 1d 	ldub  [ %l0 + %i5 ], %i4                       
40019988:	85 2f 20 18 	sll  %i4, 0x18, %g2                            
4001998c:	80 a0 a0 00 	cmp  %g2, 0                                    
40019990:	02 80 00 04 	be  400199a0 <msdos_long_to_short+0x1c4>       
40019994:	80 a6 40 1d 	cmp  %i1, %i5                                  
40019998:	34 bf ff ce 	bg,a   400198d0 <msdos_long_to_short+0xf4>     
4001999c:	b7 38 a0 18 	sra  %g2, 0x18, %i3                            
400199a0:	a4 0c c0 12 	and  %l3, %l2, %l2                             
                                                                      
        count++;                                                      
        name++;                                                       
    }                                                                 
                                                                      
    if (lowercase && uppercase)                                       
400199a4:	80 8c a0 ff 	btst  0xff, %l2                                
400199a8:	12 bf ff d1 	bne  400198ec <msdos_long_to_short+0x110>      <== NEVER TAKEN
400199ac:	b0 10 20 02 	mov  2, %i0                                    
    }                                                                 
                                                                      
#if MSDOS_NAME_TYPE_PRINT                                             
    printf ("MSDOS_NAME_TYPE: SHORT[1]\n");                           
#endif                                                                
    return MSDOS_NAME_SHORT;                                          
400199b0:	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);                      
400199b4:	90 10 00 10 	mov  %l0, %o0                                  
400199b8:	92 10 00 19 	mov  %i1, %o1                                  
400199bc:	40 00 0b 8f 	call  4001c7f8 <msdos_filename_unix2dos>       
400199c0:	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;                                                      
400199c4:	81 c7 e0 08 	ret                                            
400199c8:	81 e8 00 00 	restore                                        
     */                                                               
    for (i = 0; i < lfn_len; i++)                                     
        if ((lfn[i] != ' ') && (lfn[i] != '.'))                       
            break;                                                    
                                                                      
    if (i == lfn_len)                                                 
400199cc:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
400199d0:	12 bf ff f8 	bne  400199b0 <msdos_long_to_short+0x1d4>      <== NOT EXECUTED
400199d4:	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;                                                      
}                                                                     
400199d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400199dc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                return MSDOS_NAME_LONG;                               
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            if (count == 8 && !is_dot)                                
400199e0:	80 a5 a0 00 	cmp  %l6, 0                                    
400199e4:	12 bf ff de 	bne  4001995c <msdos_long_to_short+0x180>      <== NEVER TAKEN
400199e8:	82 07 3f bf 	add  %i4, -65, %g1                             
400199ec:	80 a7 60 08 	cmp  %i5, 8                                    
400199f0:	12 bf ff dc 	bne  40019960 <msdos_long_to_short+0x184>      
400199f4:	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;                                       
400199f8:	10 bf ff bd 	b  400198ec <msdos_long_to_short+0x110>        
400199fc:	b0 10 20 02 	mov  2, %i0                                    
#endif                                                                
                                                                      
        if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
            return type;                                              
                                                                      
        if (dot_at >= 0)                                              
40019a00:	80 a4 7f ff 	cmp  %l1, -1                                   
40019a04:	32 bf ff ba 	bne,a   400198ec <msdos_long_to_short+0x110>   
40019a08:	b0 10 20 02 	mov  2, %i0                                    
40019a0c:	10 bf ff dd 	b  40019980 <msdos_long_to_short+0x1a4>        
40019a10:	a2 10 00 1d 	mov  %i5, %l1                                  
                                                                      

4000fbb0 <msdos_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
4000fbb0:	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))                                                
4000fbb4:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
    const char *name,                                                 
    size_t namelen,                                                   
    mode_t mode,                                                      
    dev_t dev                                                         
)                                                                     
{                                                                     
4000fbb8:	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))                                                
4000fbbc:	82 0e c0 01 	and  %i3, %g1, %g1                             
4000fbc0:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
    const char *name,                                                 
    size_t namelen,                                                   
    mode_t mode,                                                      
    dev_t dev                                                         
)                                                                     
{                                                                     
4000fbc4:	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))                                                
4000fbc8:	80 a0 40 02 	cmp  %g1, %g2                                  
4000fbcc:	02 80 00 09 	be  4000fbf0 <msdos_mknod+0x40>                
4000fbd0:	b6 10 00 1a 	mov  %i2, %i3                                  
    {                                                                 
       type = MSDOS_DIRECTORY;                                        
    }                                                                 
    else if (S_ISREG(mode))                                           
4000fbd4:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
4000fbd8:	80 a0 40 02 	cmp  %g1, %g2                                  
4000fbdc:	12 80 00 09 	bne  4000fc00 <msdos_mknod+0x50>               <== NEVER TAKEN
4000fbe0:	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);
4000fbe4:	b4 10 00 03 	mov  %g3, %i2                                  
4000fbe8:	40 00 25 9c 	call  40019258 <msdos_creat_node>              
4000fbec:	9b e8 20 00 	restore  %g0, 0, %o5                           
    /*                                                                
     *  Figure out what type of msdos node this is.                   
     */                                                               
    if (S_ISDIR(mode))                                                
    {                                                                 
       type = MSDOS_DIRECTORY;                                        
4000fbf0:	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);
4000fbf4:	b4 10 00 03 	mov  %g3, %i2                                  
4000fbf8:	40 00 25 98 	call  40019258 <msdos_creat_node>              
4000fbfc:	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);                 
4000fc00:	40 00 36 64 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000fc04:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000fc08:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4000fc0c:	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;                                                        
}                                                                     
4000fc10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fc14:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000fc24 <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 ) {
4000fc24:	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;            
4000fc28:	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,                             
4000fc2c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4000fc30:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000fc34:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
4000fc38:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4000fc3c:	19 00 00 20 	sethi  %hi(0x8000), %o4                        <== NOT EXECUTED
4000fc40:	40 00 25 86 	call  40019258 <msdos_creat_node>              <== NOT EXECUTED
4000fc44:	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)                                                  
4000fc48:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000fc4c:	02 80 00 04 	be  4000fc5c <msdos_rename+0x38>               <== NOT EXECUTED
4000fc50:	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;                                                        
}                                                                     
4000fc54:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fc58:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * mark file removed                                              
     */                                                               
    rc = msdos_set_first_char4file_name(old_loc->mt_entry,            
4000fc5c:	f0 06 60 14 	ld  [ %i1 + 0x14 ], %i0                        <== NOT EXECUTED
4000fc60:	b4 10 20 e5 	mov  0xe5, %i2                                 <== NOT EXECUTED
4000fc64:	40 00 28 15 	call  40019cb8 <msdos_set_first_char4file_name><== NOT EXECUTED
4000fc68:	93 ef 60 20 	restore  %i5, 0x20, %o1                        <== NOT EXECUTED
                                                                      

4000fc6c <msdos_rmnod>: #include "msdos.h" int msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc, const rtems_filesystem_location_info_t *pathloc) {
4000fc6c:	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;                 
4000fc70:	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;          
4000fc74:	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)                     
4000fc78:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000fc7c:	80 a0 60 00 	cmp  %g1, 0                                    
4000fc80:	12 80 00 16 	bne  4000fcd8 <msdos_rmnod+0x6c>               
4000fc84:	f8 02 20 08 	ld  [ %o0 + 8 ], %i4                           
    {                                                                 
        bool is_empty = false;                                        
4000fc88:	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);
4000fc8c:	92 10 00 1d 	mov  %i5, %o1                                  
4000fc90:	40 00 28 76 	call  40019e68 <msdos_dir_is_empty>            
4000fc94:	94 07 bf ff 	add  %fp, -1, %o2                              
        if (rc != RC_OK)                                              
4000fc98:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000fc9c:	12 80 00 0d 	bne  4000fcd0 <msdos_rmnod+0x64>               <== NEVER TAKEN
4000fca0:	c2 0f bf ff 	ldub  [ %fp + -1 ], %g1                        
        {                                                             
            return rc;                                                
        }                                                             
                                                                      
        if (!is_empty)                                                
4000fca4:	80 a0 60 00 	cmp  %g1, 0                                    
4000fca8:	02 80 00 16 	be  4000fd00 <msdos_rmnod+0x94>                
4000fcac:	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)                                    
4000fcb0:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000fcb4:	80 a0 60 01 	cmp  %g1, 1                                    
4000fcb8:	28 80 00 08 	bleu,a   4000fcd8 <msdos_rmnod+0x6c>           <== ALWAYS TAKEN
4000fcbc:	d0 06 60 14 	ld  [ %i1 + 0x14 ], %o0                        
        {                                                             
            rtems_set_errno_and_return_minus_one(EBUSY);              
4000fcc0:	40 00 36 34 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000fcc4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000fcc8:	82 10 20 10 	mov  0x10, %g1                                 <== NOT EXECUTED
4000fccc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4000fcd0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fcd4:	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,
4000fcd8:	92 07 60 20 	add  %i5, 0x20, %o1                            
4000fcdc:	40 00 27 f7 	call  40019cb8 <msdos_set_first_char4file_name>
4000fce0:	94 10 20 e5 	mov  0xe5, %o2                                 
                                        MSDOS_THIS_DIR_ENTRY_EMPTY);  
    if (rc != RC_OK)                                                  
4000fce4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000fce8:	12 bf ff fa 	bne  4000fcd0 <msdos_rmnod+0x64>               <== NEVER TAKEN
4000fcec:	90 10 00 1c 	mov  %i4, %o0                                  
    {                                                                 
        return rc;                                                    
    }                                                                 
                                                                      
    fat_file_mark_removed(&fs_info->fat, fat_fd);                     
4000fcf0:	40 00 11 79 	call  400142d4 <fat_file_mark_removed>         
4000fcf4:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
    return rc;                                                        
}                                                                     
4000fcf8:	81 c7 e0 08 	ret                                            
4000fcfc:	81 e8 00 00 	restore                                        
            return rc;                                                
        }                                                             
                                                                      
        if (!is_empty)                                                
        {                                                             
            rtems_set_errno_and_return_minus_one(ENOTEMPTY);          
4000fd00:	40 00 36 24 	call  4001d590 <__errno>                       
4000fd04:	b0 10 3f ff 	mov  -1, %i0                                   
4000fd08:	82 10 20 5a 	mov  0x5a, %g1                                 
4000fd0c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000fd10:	81 c7 e0 08 	ret                                            
4000fd14:	81 e8 00 00 	restore                                        
                                                                      

40019a14 <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 ) {
40019a14:	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);             
40019a18:	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;                     
40019a1c:	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);             
40019a20:	92 07 bf fe 	add  %fp, -2, %o1                              
40019a24:	40 00 0a c9 	call  4001c548 <msdos_date_unix2dos>           
40019a28:	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);
40019a2c:	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)) )
40019a30:	80 a0 60 00 	cmp  %g1, 0                                    
40019a34:	32 80 00 07 	bne,a   40019a50 <msdos_set_dir_wrt_time_and_date+0x3c>
40019a38:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         
40019a3c:	c4 0f 60 0e 	ldub  [ %i5 + 0xe ], %g2                       
40019a40:	80 88 a0 03 	btst  3, %g2                                   
40019a44:	32 80 00 07 	bne,a   40019a60 <msdos_set_dir_wrt_time_and_date+0x4c><== ALWAYS TAKEN
40019a48:	f6 07 60 20 	ld  [ %i5 + 0x20 ], %i3                        
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
40019a4c:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         <== NOT EXECUTED
40019a50:	c4 07 60 34 	ld  [ %i5 + 0x34 ], %g2                        
40019a54:	b6 00 7f fe 	add  %g1, -2, %i3                              
40019a58:	b7 2e c0 03 	sll  %i3, %g3, %i3                             
40019a5c:	b6 06 c0 02 	add  %i3, %g2, %i3                             
    sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);  
40019a60:	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);    
40019a64:	f8 17 40 00 	lduh  [ %i5 ], %i4                             
                                                                      
    time_val = CT_LE_W(time_val);                                     
40019a68:	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);  
40019a6c:	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);                                     
40019a70:	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);  
40019a74:	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);    
40019a78:	b8 07 3f ff 	add  %i4, -1, %i4                              
40019a7c:	b8 0f 00 02 	and  %i4, %g2, %i4                             
                                                                      
    time_val = CT_LE_W(time_val);                                     
40019a80:	85 30 60 08 	srl  %g1, 8, %g2                               
40019a84:	83 30 60 18 	srl  %g1, 0x18, %g1                            
40019a88:	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);  
40019a8c:	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,
40019a90:	94 07 20 16 	add  %i4, 0x16, %o2                            
40019a94:	92 10 00 1b 	mov  %i3, %o1                                  
40019a98:	96 10 20 02 	mov  2, %o3                                    
40019a9c:	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);                                     
40019aa0:	c2 37 bf fc 	sth  %g1, [ %fp + -4 ]                         
    ret1 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
40019aa4:	7f ff eb 2d 	call  40014758 <fat_sector_write>              
40019aa8:	90 10 00 1d 	mov  %i5, %o0                                  
                            2, (char *)(&time_val));                  
    date = CT_LE_W(date);                                             
40019aac:	c2 17 bf fe 	lduh  [ %fp + -2 ], %g1                        
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40019ab0:	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);                                             
40019ab4:	83 28 60 10 	sll  %g1, 0x10, %g1                            
40019ab8:	85 30 60 08 	srl  %g1, 8, %g2                               
40019abc:	83 30 60 18 	srl  %g1, 0x18, %g1                            
40019ac0:	82 10 80 01 	or  %g2, %g1, %g1                              
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40019ac4:	96 10 20 02 	mov  2, %o3                                    
40019ac8:	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);                                             
40019acc:	c2 37 bf fe 	sth  %g1, [ %fp + -2 ]                         
    ret2 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
40019ad0:	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,
40019ad4:	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,
40019ad8:	7f ff eb 20 	call  40014758 <fat_sector_write>              
40019adc:	90 10 00 1d 	mov  %i5, %o0                                  
                            2, (char *)(&date));                      
    ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
40019ae0:	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,
40019ae4:	b4 10 00 08 	mov  %o0, %i2                                  
                            2, (char *)(&date));                      
    ret3 = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
40019ae8:	94 07 20 12 	add  %i4, 0x12, %o2                            
40019aec:	90 10 00 1d 	mov  %i5, %o0                                  
40019af0:	96 10 20 02 	mov  2, %o3                                    
40019af4:	7f ff eb 19 	call  40014758 <fat_sector_write>              
40019af8:	98 07 bf fe 	add  %fp, -2, %o4                              
                            2, (char *)(&date));                      
                                                                      
    if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )                     
40019afc:	80 a6 a0 00 	cmp  %i2, 0                                    
40019b00:	06 80 00 08 	bl  40019b20 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40019b04:	80 a6 60 00 	cmp  %i1, 0                                    
40019b08:	06 80 00 06 	bl  40019b20 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40019b0c:	80 a2 20 00 	cmp  %o0, 0                                    
40019b10:	06 80 00 04 	bl  40019b20 <msdos_set_dir_wrt_time_and_date+0x10c><== NEVER TAKEN
40019b14:	01 00 00 00 	nop                                            
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
40019b18:	81 c7 e0 08 	ret                                            
40019b1c:	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;                                                    
40019b20:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40019b24:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

40019c14 <msdos_set_file_size>: int msdos_set_file_size( rtems_filesystem_mount_table_entry_t *mt_entry, fat_file_fd_t *fat_fd ) {
40019c14:	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);
40019c18:	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)) )
40019c1c:	80 a0 60 00 	cmp  %g1, 0                                    
40019c20:	12 80 00 06 	bne  40019c38 <msdos_set_file_size+0x24>       
40019c24:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           
40019c28:	c4 0a 20 0e 	ldub  [ %o0 + 0xe ], %g2                       
40019c2c:	80 88 a0 03 	btst  3, %g2                                   
40019c30:	32 80 00 07 	bne,a   40019c4c <msdos_set_file_size+0x38>    <== ALWAYS TAKEN
40019c34:	d2 02 20 20 	ld  [ %o0 + 0x20 ], %o1                        
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
40019c38:	c6 0a 20 05 	ldub  [ %o0 + 5 ], %g3                         
40019c3c:	c4 02 20 34 	ld  [ %o0 + 0x34 ], %g2                        
40019c40:	92 00 7f fe 	add  %g1, -2, %o1                              
40019c44:	93 2a 40 03 	sll  %o1, %g3, %o1                             
40019c48:	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));  
40019c4c:	c6 12 00 00 	lduh  [ %o0 ], %g3                             
                                                                      
    le_new_length = CT_LE_L((fat_fd->fat_file_size));                 
40019c50:	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);  
40019c54:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
40019c58:	c8 0a 20 02 	ldub  [ %o0 + 2 ], %g4                         
    byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));  
40019c5c:	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);  
40019c60:	89 30 80 04 	srl  %g2, %g4, %g4                             
    byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));  
40019c64:	94 08 c0 02 	and  %g3, %g2, %o2                             
40019c68:	b9 28 60 18 	sll  %g1, 0x18, %i4                            
  uint32_t value                                                      
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
40019c6c:	87 30 60 18 	srl  %g1, 0x18, %g3                            
  byte3 = (value >> 16) & 0xff;                                       
  byte2 = (value >> 8)  & 0xff;                                       
40019c70:	bb 30 60 08 	srl  %g1, 8, %i5                               
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40019c74:	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;                                       
40019c78:	ba 0f 60 ff 	and  %i5, 0xff, %i5                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
40019c7c:	83 30 60 10 	srl  %g1, 0x10, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40019c80:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
)                                                                     
{                                                                     
  uint32_t   byte1, byte2, byte3, byte4, swapped;                     
                                                                      
  byte4 = (value >> 24) & 0xff;                                       
  byte3 = (value >> 16) & 0xff;                                       
40019c84:	82 08 60 ff 	and  %g1, 0xff, %g1                            
  byte2 = (value >> 8)  & 0xff;                                       
  byte1 =  value        & 0xff;                                       
                                                                      
  swapped = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;     
40019c88:	86 10 c0 1d 	or  %g3, %i5, %g3                              
40019c8c:	83 28 60 08 	sll  %g1, 8, %g1                               
40019c90:	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,
40019c94:	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));                 
40019c98:	c6 27 bf fc 	st  %g3, [ %fp + -4 ]                          
    ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
40019c9c:	94 02 a0 1c 	add  %o2, 0x1c, %o2                            
40019ca0:	96 10 20 04 	mov  4, %o3                                    
40019ca4:	7f ff ea ad 	call  40014758 <fat_sector_write>              
40019ca8:	98 07 bf fc 	add  %fp, -4, %o4                              
                           (char *)(&le_new_length));                 
    if ( ret < 0 )                                                    
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
40019cac:	b1 3a 20 1f 	sra  %o0, 0x1f, %i0                            
40019cb0:	81 c7 e0 08 	ret                                            
40019cb4:	81 e8 00 00 	restore                                        
                                                                      

40019cb8 <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 ) {
40019cb8:	9d e3 bf 90 	save  %sp, -112, %sp                           
    ssize_t          ret;                                             
    msdos_fs_info_t *fs_info = mt_entry->fs_info;                     
40019cbc:	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;                            
40019cc0:	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;                          
40019cc4:	c8 06 60 08 	ld  [ %i1 + 8 ], %g4                           
40019cc8:	c6 06 60 0c 	ld  [ %i1 + 0xc ], %g3                         
    fat_pos_t        end = dir_pos->sname;                            
40019ccc:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
                                                                      
    if ((end.cln == fs_info->fat.vol.rdir_cl) &&                      
40019cd0:	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                       
    )                                                                 
{                                                                     
40019cd4:	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;                          
40019cd8:	c8 27 bf f0 	st  %g4, [ %fp + -16 ]                         
40019cdc:	c6 27 bf f4 	st  %g3, [ %fp + -12 ]                         
    fat_pos_t        end = dir_pos->sname;                            
40019ce0:	f8 27 bf f8 	st  %i4, [ %fp + -8 ]                          
                                                                      
    if ((end.cln == fs_info->fat.vol.rdir_cl) &&                      
40019ce4:	80 a7 00 02 	cmp  %i4, %g2                                  
40019ce8:	02 80 00 56 	be  40019e40 <msdos_set_first_char4file_name+0x188><== ALWAYS TAKEN
40019cec:	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)                    
40019cf0:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           <== NOT EXECUTED
40019cf4:	80 a0 bf ff 	cmp  %g2, -1                                   <== NOT EXECUTED
40019cf8:	02 80 00 59 	be  40019e5c <msdos_set_first_char4file_name+0x1a4><== NOT EXECUTED
40019cfc:	f6 17 60 06 	lduh  [ %i5 + 6 ], %i3                         <== NOT EXECUTED
40019d00:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40019d04:	c4 0f 60 02 	ldub  [ %i5 + 2 ], %g2                         
40019d08:	d4 17 40 00 	lduh  [ %i5 ], %o2                             
40019d0c:	10 80 00 1d 	b  40019d80 <msdos_set_first_char4file_name+0xc8>
40019d10:	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)) )
40019d14:	80 88 e0 03 	btst  3, %g3                                   
40019d18:	22 80 00 1e 	be,a   40019d90 <msdos_set_first_char4file_name+0xd8><== NEVER TAKEN
40019d1c:	c8 0f 60 05 	ldub  [ %i5 + 5 ], %g4                         <== NOT EXECUTED
        return fs_info->vol.rdir_loc;                                 
40019d20:	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));      
40019d24:	85 30 40 02 	srl  %g1, %g2, %g2                             
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
40019d28:	95 2a a0 10 	sll  %o2, 0x10, %o2                            
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019d2c:	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));       
40019d30:	95 32 a0 10 	srl  %o2, 0x10, %o2                            
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019d34:	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));       
40019d38:	94 02 bf ff 	add  %o2, -1, %o2                              
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019d3c:	96 10 20 01 	mov  1, %o3                                    
40019d40:	94 08 40 0a 	and  %g1, %o2, %o2                             
40019d44:	7f ff ea 85 	call  40014758 <fat_sector_write>              
40019d48:	98 07 a0 4c 	add  %fp, 0x4c, %o4                            
                             1, &fchar);                              
      if (ret < 0)                                                    
40019d4c:	80 a2 20 00 	cmp  %o0, 0                                    
40019d50:	06 80 00 22 	bl  40019dd8 <msdos_set_first_char4file_name+0x120><== NEVER TAKEN
40019d54:	90 10 3f ff 	mov  -1, %o0                                   
        return -1;                                                    
                                                                      
      if ((start.cln == end.cln) && (start.ofs == end.ofs))           
40019d58:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         
40019d5c:	80 a7 00 09 	cmp  %i4, %o1                                  
40019d60:	02 80 00 20 	be  40019de0 <msdos_set_first_char4file_name+0x128><== ALWAYS TAKEN
40019d64:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
        break;                                                        
                                                                      
      start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;                 
40019d68:	82 00 60 20 	add  %g1, 0x20, %g1                            <== NOT EXECUTED
      if (start.ofs >= dir_block_size)                                
40019d6c:	80 a6 c0 01 	cmp  %i3, %g1                                  
40019d70:	08 80 00 23 	bleu  40019dfc <msdos_set_first_char4file_name+0x144><== NEVER TAKEN
40019d74:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
40019d78:	c4 0f 60 02 	ldub  [ %i5 + 2 ], %g2                         
40019d7c:	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)) )
40019d80:	80 a2 60 00 	cmp  %o1, 0                                    
40019d84:	22 bf ff e4 	be,a   40019d14 <msdos_set_first_char4file_name+0x5c><== ALWAYS TAKEN
40019d88:	c6 0f 60 0e 	ldub  [ %i5 + 0xe ], %g3                       
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
40019d8c:	c8 0f 60 05 	ldub  [ %i5 + 5 ], %g4                         <== NOT EXECUTED
40019d90:	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));      
40019d94:	85 30 40 02 	srl  %g1, %g2, %g2                             <== NOT EXECUTED
40019d98:	92 02 7f fe 	add  %o1, -2, %o1                              <== NOT EXECUTED
      uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));       
40019d9c:	95 2a a0 10 	sll  %o2, 0x10, %o2                            <== NOT EXECUTED
40019da0:	93 2a 40 04 	sll  %o1, %g4, %o1                             <== NOT EXECUTED
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019da4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40019da8:	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));       
40019dac:	95 32 a0 10 	srl  %o2, 0x10, %o2                            <== NOT EXECUTED
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019db0:	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));       
40019db4:	94 02 bf ff 	add  %o2, -1, %o2                              <== NOT EXECUTED
                                                                      
      ret = fat_sector_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
40019db8:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
40019dbc:	94 08 40 0a 	and  %g1, %o2, %o2                             <== NOT EXECUTED
40019dc0:	7f ff ea 66 	call  40014758 <fat_sector_write>              <== NOT EXECUTED
40019dc4:	98 07 a0 4c 	add  %fp, 0x4c, %o4                            <== NOT EXECUTED
                             1, &fchar);                              
      if (ret < 0)                                                    
40019dc8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40019dcc:	16 bf ff e4 	bge  40019d5c <msdos_set_first_char4file_name+0xa4><== NOT EXECUTED
40019dd0:	d2 07 bf f0 	ld  [ %fp + -16 ], %o1                         <== NOT EXECUTED
        return -1;                                                    
40019dd4:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
        start.ofs = 0;                                                
      }                                                               
    }                                                                 
                                                                      
    return  RC_OK;                                                    
}                                                                     
40019dd8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40019ddc:	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))           
40019de0:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
40019de4:	80 a0 40 02 	cmp  %g1, %g2                                  
40019de8:	32 bf ff e1 	bne,a   40019d6c <msdos_set_first_char4file_name+0xb4>
40019dec:	82 00 60 20 	add  %g1, 0x20, %g1                            
          return rc;                                                  
        start.ofs = 0;                                                
      }                                                               
    }                                                                 
                                                                      
    return  RC_OK;                                                    
40019df0:	90 10 20 00 	clr  %o0                                       
}                                                                     
40019df4:	81 c7 e0 08 	ret                                            
40019df8:	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) &&                  
40019dfc:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
40019e00:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
40019e04:	12 80 00 06 	bne  40019e1c <msdos_set_first_char4file_name+0x164><== NOT EXECUTED
40019e08:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
            (fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))        
40019e0c:	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) &&                  
40019e10:	80 88 60 03 	btst  3, %g1                                   <== NOT EXECUTED
40019e14:	32 bf ff f8 	bne,a   40019df4 <msdos_set_first_char4file_name+0x13c><== NOT EXECUTED
40019e18:	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);
40019e1c:	40 00 05 48 	call  4001b33c <fat_get_fat_cluster>           <== NOT EXECUTED
40019e20:	94 07 bf f0 	add  %fp, -16, %o2                             <== NOT EXECUTED
        if ( rc != RC_OK )                                            
40019e24:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40019e28:	12 bf ff ec 	bne  40019dd8 <msdos_set_first_char4file_name+0x120><== NOT EXECUTED
40019e2c:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
          return rc;                                                  
        start.ofs = 0;                                                
40019e30:	c0 27 bf f4 	clr  [ %fp + -12 ]                             <== NOT EXECUTED
40019e34:	d4 17 40 00 	lduh  [ %i5 ], %o2                             <== NOT EXECUTED
40019e38:	10 bf ff b5 	b  40019d0c <msdos_set_first_char4file_name+0x54><== NOT EXECUTED
40019e3c:	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)))            
40019e40:	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) &&                      
40019e44:	80 88 a0 03 	btst  3, %g2                                   
40019e48:	02 bf ff ab 	be  40019cf4 <msdos_set_first_char4file_name+0x3c><== NEVER TAKEN
40019e4c:	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)                    
40019e50:	80 a0 bf ff 	cmp  %g2, -1                                   
40019e54:	12 bf ff ab 	bne  40019d00 <msdos_set_first_char4file_name+0x48>
40019e58:	f6 07 60 2c 	ld  [ %i5 + 0x2c ], %i3                        
      start = dir_pos->sname;                                         
40019e5c:	f8 27 bf f0 	st  %i4, [ %fp + -16 ]                         
40019e60:	10 bf ff a8 	b  40019d00 <msdos_set_first_char4file_name+0x48>
40019e64:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
                                                                      

40019b28 <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 ) {
40019b28:	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);
40019b2c:	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;                                    
40019b30:	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;                     
40019b34:	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)) )
40019b38:	80 a0 60 00 	cmp  %g1, 0                                    
40019b3c:	12 80 00 06 	bne  40019b54 <msdos_set_first_cluster_num+0x2c>
40019b40:	f8 06 60 1c 	ld  [ %i1 + 0x1c ], %i4                        
40019b44:	c4 0f 60 0e 	ldub  [ %i5 + 0xe ], %g2                       
40019b48:	80 88 a0 03 	btst  3, %g2                                   
40019b4c:	32 80 00 07 	bne,a   40019b68 <msdos_set_first_cluster_num+0x40><== ALWAYS TAKEN
40019b50:	f4 07 60 20 	ld  [ %i5 + 0x20 ], %i2                        
        return fs_info->vol.rdir_loc;                                 
                                                                      
    return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +        
40019b54:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         
40019b58:	c4 07 60 34 	ld  [ %i5 + 0x34 ], %g2                        
40019b5c:	b4 00 7f fe 	add  %g1, -2, %i2                              
40019b60:	b5 2e 80 03 	sll  %i2, %g3, %i2                             
40019b64:	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);  
40019b68:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
40019b6c:	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);    
40019b70:	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);  
40019b74:	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);    
40019b78:	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);  
40019b7c:	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);    
40019b80:	b6 0e c0 01 	and  %i3, %g1, %i3                             
                                                                      
    le_cl_low = CT_LE_W((uint16_t  )(new_cln & 0x0000FFFF));          
40019b84:	85 2f 20 10 	sll  %i4, 0x10, %g2                            
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
40019b88:	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));          
40019b8c:	85 30 a0 18 	srl  %g2, 0x18, %g2                            
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
40019b90:	b2 16 63 ff 	or  %i1, 0x3ff, %i1                            
40019b94:	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));          
40019b98:	83 28 60 08 	sll  %g1, 8, %g1                               
40019b9c:	82 10 40 02 	or  %g1, %g2, %g1                              
    ret1 = fat_sector_write(&fs_info->fat, sec,                       
40019ba0:	94 06 e0 1a 	add  %i3, 0x1a, %o2                            
40019ba4:	92 10 00 1a 	mov  %i2, %o1                                  
40019ba8:	96 10 20 02 	mov  2, %o3                                    
40019bac:	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));          
40019bb0:	c2 37 bf fc 	sth  %g1, [ %fp + -4 ]                         
    ret1 = fat_sector_write(&fs_info->fat, sec,                       
40019bb4:	7f ff ea e9 	call  40014758 <fat_sector_write>              
40019bb8:	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));   
40019bbc:	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,                       
40019bc0:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
    return rc;                                                        
}                                                                     
40019bc4:	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,                       
40019bc8:	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));   
40019bcc:	b9 37 20 08 	srl  %i4, 8, %i4                               
40019bd0:	b3 2e 60 08 	sll  %i1, 8, %i1                               
    ret2 = fat_sector_write(&fs_info->fat, sec,                       
40019bd4:	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));   
40019bd8:	b8 16 40 1c 	or  %i1, %i4, %i4                              
    ret2 = fat_sector_write(&fs_info->fat, sec,                       
40019bdc:	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));   
40019be0:	f8 37 bf fe 	sth  %i4, [ %fp + -2 ]                         
    ret2 = fat_sector_write(&fs_info->fat, sec,                       
40019be4:	96 10 20 02 	mov  2, %o3                                    
40019be8:	7f ff ea dc 	call  40014758 <fat_sector_write>              
40019bec:	98 07 bf fe 	add  %fp, -2, %o4                              
                            byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,  
                            (char *)(&le_cl_hi));                     
    if ( (ret1 < 0) || (ret2 < 0) )                                   
40019bf0:	80 a2 20 00 	cmp  %o0, 0                                    
40019bf4:	06 80 00 06 	bl  40019c0c <msdos_set_first_cluster_num+0xe4><== NEVER TAKEN
40019bf8:	80 a4 20 00 	cmp  %l0, 0                                    
40019bfc:	06 80 00 04 	bl  40019c0c <msdos_set_first_cluster_num+0xe4><== NEVER TAKEN
40019c00:	b0 10 20 00 	clr  %i0                                       
        return -1;                                                    
                                                                      
    return RC_OK;                                                     
}                                                                     
40019c04:	81 c7 e0 08 	ret                                            
40019c08:	81 e8 00 00 	restore                                        
40019c0c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40019c10:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

4000e7c4 <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 ) {
4000e7c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int      ret_val = -1;                                              
  uint32_t onebit;                                                    
                                                                      
  if ( rqdata != NULL && rqdata->sectors_per_cluster > 0 ) {          
4000e7c8:	80 a6 20 00 	cmp  %i0, 0                                    
4000e7cc:	22 80 00 07 	be,a   4000e7e8 <msdos_set_sectors_per_cluster_from_request+0x24>
4000e7d0:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
4000e7d4:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
4000e7d8:	80 a0 60 00 	cmp  %g1, 0                                    
4000e7dc:	22 80 00 03 	be,a   4000e7e8 <msdos_set_sectors_per_cluster_from_request+0x24>
4000e7e0:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    fmt_params->sectors_per_cluster = rqdata->sectors_per_cluster;    
4000e7e4:	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 )                    
{                                                                     
4000e7e8:	b8 10 20 08 	mov  8, %i4                                    
4000e7ec:	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 ) {                
4000e7f0:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000e7f4:	2a 80 00 0b 	bcs,a   4000e820 <msdos_set_sectors_per_cluster_from_request+0x5c>
4000e7f8:	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 ) {                
4000e7fc:	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;                       
4000e800:	fa 26 60 0c 	st  %i5, [ %i1 + 0xc ]                         
      if (   fmt_params->sectors_per_cluster                          
          <= 32768L / fmt_params->bytes_per_sector ) {                
4000e804:	7f ff cf 9c 	call  40002674 <.udiv>                         
4000e808:	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                          
4000e80c:	80 a2 00 1d 	cmp  %o0, %i5                                  
4000e810:	0a 80 00 04 	bcs  4000e820 <msdos_set_sectors_per_cluster_from_request+0x5c><== NEVER TAKEN
4000e814:	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;                                                  
4000e818:	81 c7 e0 08 	ret                                            
4000e81c:	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 ) {           
4000e820:	02 80 00 04 	be  4000e830 <msdos_set_sectors_per_cluster_from_request+0x6c><== NEVER TAKEN
4000e824:	bb 37 60 01 	srl  %i5, 1, %i5                               
4000e828:	10 bf ff f2 	b  4000e7f0 <msdos_set_sectors_per_cluster_from_request+0x2c>
4000e82c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (ret_val != 0) {                                                 
    errno = EINVAL;                                                   
4000e830:	40 00 3b 58 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000e834:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000e838:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4000e83c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return ret_val;                                                     
}                                                                     
4000e840:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e844:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001b1dc <msdos_sync>: return MSDOS_NAME_NOT_FOUND_ERR; } int msdos_sync(rtems_libio_t *iop) {
4001b1dc:	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;     
4001b1e0:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001b1e4:	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;     
4001b1e8:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
                                                                      
    sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,        
4001b1ec:	94 10 20 00 	clr  %o2                                       
4001b1f0:	7f ff bd 02 	call  4000a5f8 <rtems_semaphore_obtain>        
4001b1f4:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
                                MSDOS_VOLUME_SEMAPHORE_TIMEOUT);      
    if (sc != RTEMS_SUCCESSFUL)                                       
4001b1f8:	80 a2 20 00 	cmp  %o0, 0                                    
4001b1fc:	12 80 00 09 	bne  4001b220 <msdos_sync+0x44>                <== NEVER TAKEN
4001b200:	01 00 00 00 	nop                                            
        rtems_set_errno_and_return_minus_one(EIO);                    
                                                                      
    rc = fat_sync(&fs_info->fat);                                     
4001b204:	7f ff e8 48 	call  40015324 <fat_sync>                      
4001b208:	90 10 00 1d 	mov  %i5, %o0                                  
4001b20c:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
    rtems_semaphore_release(fs_info->vol_sema);                       
4001b210:	7f ff bd 49 	call  4000a734 <rtems_semaphore_release>       
4001b214:	d0 07 60 9c 	ld  [ %i5 + 0x9c ], %o0                        
    return rc;                                                        
}                                                                     
4001b218:	81 c7 e0 08 	ret                                            
4001b21c:	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);                    
4001b220:	40 00 08 dc 	call  4001d590 <__errno>                       <== NOT EXECUTED
4001b224:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001b228:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
4001b22c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001b230:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001b234:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000f97c <msdos_unlock>: rtems_fatal_error_occurred(0xdeadbeef); } } void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry) {
4000f97c:	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);  
4000f980:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
4000f984:	7f ff eb 6c 	call  4000a734 <rtems_semaphore_release>       
4000f988:	d0 00 60 9c 	ld  [ %g1 + 0x9c ], %o0                        
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000f98c:	80 a2 20 00 	cmp  %o0, 0                                    
4000f990:	12 80 00 04 	bne  4000f9a0 <msdos_unlock+0x24>              <== NEVER TAKEN
4000f994:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
4000f998:	81 c7 e0 08 	ret                                            
4000f99c:	81 e8 00 00 	restore                                        
    rtems_fatal_error_occurred(0xdeadbeef);                           
4000f9a0:	7f ff ec f7 	call  4000ad7c <rtems_fatal_error_occurred>    <== NOT EXECUTED
4000f9a4:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

40004d74 <newlib_delete_hook>: void newlib_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) {
40004d74:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   * The reentrancy structure was allocated by newlib using malloc()  
   */                                                                 
                                                                      
  if (current_task == deleted_task) {                                 
    ptr = _REENT;                                                     
40004d78:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
                                                                      
  /*                                                                  
   * The reentrancy structure was allocated by newlib using malloc()  
   */                                                                 
                                                                      
  if (current_task == deleted_task) {                                 
40004d7c:	80 a6 00 19 	cmp  %i0, %i1                                  
40004d80:	02 80 00 03 	be  40004d8c <newlib_delete_hook+0x18>         
40004d84:	fa 00 63 68 	ld  [ %g1 + 0x368 ], %i5                       
    ptr = _REENT;                                                     
  } else {                                                            
    ptr = deleted_task->libc_reent;                                   
40004d88:	fa 06 61 48 	ld  [ %i1 + 0x148 ], %i5                       
  }                                                                   
                                                                      
  if (ptr && ptr != _global_impure_ptr) {                             
40004d8c:	80 a7 60 00 	cmp  %i5, 0                                    
40004d90:	02 80 00 0b 	be  40004dbc <newlib_delete_hook+0x48>         <== NEVER TAKEN
40004d94:	03 10 00 7a 	sethi  %hi(0x4001e800), %g1                    
40004d98:	c2 00 62 a8 	ld  [ %g1 + 0x2a8 ], %g1	! 4001eaa8 <_global_impure_ptr>
40004d9c:	80 a7 40 01 	cmp  %i5, %g1                                  
40004da0:	02 80 00 07 	be  40004dbc <newlib_delete_hook+0x48>         
40004da4:	13 10 00 12 	sethi  %hi(0x40004800), %o1                    
    _reclaim_reent(ptr);                                              
*/                                                                    
    /*                                                                
     *  Just in case there are some buffers lying around.             
     */                                                               
    _fwalk(ptr, newlib_free_buffers);                                 
40004da8:	90 10 00 1d 	mov  %i5, %o0                                  
40004dac:	40 00 30 f2 	call  40011174 <_fwalk>                        
40004db0:	92 12 63 64 	or  %o1, 0x364, %o1                            
#if REENT_MALLOCED                                                    
    free(ptr);                                                        
#else                                                                 
    _Workspace_Free(ptr);                                             
40004db4:	40 00 1d 1e 	call  4000c22c <_Workspace_Free>               
40004db8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  /*                                                                  
   * Require the switch back to another task to install its own       
   */                                                                 
                                                                      
  if ( current_task == deleted_task ) {                               
40004dbc:	80 a6 00 19 	cmp  %i0, %i1                                  
40004dc0:	12 80 00 04 	bne  40004dd0 <newlib_delete_hook+0x5c>        
40004dc4:	c0 26 61 48 	clr  [ %i1 + 0x148 ]                           
    _REENT = 0;                                                       
40004dc8:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
40004dcc:	c0 20 63 68 	clr  [ %g1 + 0x368 ]	! 4001f768 <_impure_ptr>  
40004dd0:	81 c7 e0 08 	ret                                            
40004dd4:	81 e8 00 00 	restore                                        
                                                                      

40004b64 <newlib_free_buffers>: * task. */ int newlib_free_buffers( FILE *fp ) {
40004b64:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch ( fileno(fp) ) {                                             
40004b68:	40 00 30 88 	call  40010d88 <fileno>                        
40004b6c:	90 10 00 18 	mov  %i0, %o0                                  
40004b70:	80 a2 20 02 	cmp  %o0, 2                                    
40004b74:	28 80 00 06 	bleu,a   40004b8c <newlib_free_buffers+0x28>   <== ALWAYS TAKEN
40004b78:	c2 16 20 0c 	lduh  [ %i0 + 0xc ], %g1                       
        fp->_flags &= ~__SMBF;                                        
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
      }                                                               
      break;                                                          
    default:                                                          
     fclose(fp);                                                      
40004b7c:	40 00 2f c3 	call  40010a88 <fclose>                        <== NOT EXECUTED
40004b80:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  }                                                                   
  return 0;                                                           
}                                                                     
40004b84:	81 c7 e0 08 	ret                                            
40004b88:	91 e8 20 00 	restore  %g0, 0, %o0                           
{                                                                     
  switch ( fileno(fp) ) {                                             
    case 0:                                                           
    case 1:                                                           
    case 2:                                                           
      if (fp->_flags & __SMBF) {                                      
40004b8c:	80 88 60 80 	btst  0x80, %g1                                
40004b90:	02 bf ff fd 	be  40004b84 <newlib_free_buffers+0x20>        <== ALWAYS TAKEN
40004b94:	01 00 00 00 	nop                                            
        free( fp->_bf._base );                                        
40004b98:	7f ff fd 9c 	call  40004208 <free>                          <== NOT EXECUTED
40004b9c:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
        fp->_flags &= ~__SMBF;                                        
40004ba0:	c2 16 20 0c 	lduh  [ %i0 + 0xc ], %g1                       <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
40004ba4:	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;                                        
40004ba8:	82 08 7f 7f 	and  %g1, -129, %g1                            <== NOT EXECUTED
        fp->_bf._base = fp->_p = (unsigned char *) NULL;              
40004bac:	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;                                        
40004bb0:	c2 36 20 0c 	sth  %g1, [ %i0 + 0xc ]                        <== NOT EXECUTED
      break;                                                          
    default:                                                          
     fclose(fp);                                                      
  }                                                                   
  return 0;                                                           
}                                                                     
40004bb4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004bb8:	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 a2 	sethi  %hi(0x40028800), %o0                    <== NOT EXECUTED
40002034:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
40002038:	90 12 23 b8 	or  %o0, 0x3b8, %o0                            <== NOT EXECUTED
4000203c:	40 00 70 c9 	call  4001e360 <printf>                        <== NOT EXECUTED
40002040:	31 10 00 a2 	sethi  %hi(0x40028800), %i0                    <== NOT EXECUTED
    printf ("   PLEASE NOTIFY KARPINKSI!\n");                         
40002044:	40 00 71 08 	call  4001e464 <puts>                          <== NOT EXECUTED
40002048:	91 ee 23 e0 	restore  %i0, 0x3e0, %o0                       <== NOT EXECUTED
                                                                      

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

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

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

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

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

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

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

40006a6c <oproc>: /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) {
40006a6c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
40006a70:	c2 06 60 34 	ld  [ %i1 + 0x34 ], %g1                        
40006a74:	80 88 60 01 	btst  1, %g1                                   
40006a78:	02 80 00 21 	be  40006afc <oproc+0x90>                      <== NEVER TAKEN
40006a7c:	f0 2f a0 44 	stb  %i0, [ %fp + 0x44 ]                       
    switch (c) {                                                      
40006a80:	80 a6 20 09 	cmp  %i0, 9                                    
40006a84:	22 80 00 3d 	be,a   40006b78 <oproc+0x10c>                  
40006a88:	c6 06 60 28 	ld  [ %i1 + 0x28 ], %g3                        
40006a8c:	08 80 00 22 	bleu  40006b14 <oproc+0xa8>                    <== NEVER TAKEN
40006a90:	80 a6 20 08 	cmp  %i0, 8                                    
40006a94:	80 a6 20 0a 	cmp  %i0, 0xa                                  
40006a98:	02 80 00 2b 	be  40006b44 <oproc+0xd8>                      
40006a9c:	80 a6 20 0d 	cmp  %i0, 0xd                                  
40006aa0:	02 80 00 45 	be  40006bb4 <oproc+0x148>                     <== NEVER TAKEN
40006aa4:	80 88 60 10 	btst  0x10, %g1                                
      if (tty->column > 0)                                            
        tty->column--;                                                
      break;                                                          
                                                                      
    default:                                                          
      if (tty->termios.c_oflag & OLCUC)                               
40006aa8:	80 88 60 02 	btst  2, %g1                                   
        c = toupper(c);                                               
40006aac:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
      if (tty->column > 0)                                            
        tty->column--;                                                
      break;                                                          
                                                                      
    default:                                                          
      if (tty->termios.c_oflag & OLCUC)                               
40006ab0:	02 80 00 0b 	be  40006adc <oproc+0x70>                      <== ALWAYS TAKEN
40006ab4:	c2 00 63 60 	ld  [ %g1 + 0x360 ], %g1	! 4001f760 <__ctype_ptr__>
        c = toupper(c);                                               
40006ab8:	84 10 00 18 	mov  %i0, %g2                                  <== NOT EXECUTED
40006abc:	b0 00 40 18 	add  %g1, %i0, %i0                             <== NOT EXECUTED
40006ac0:	c6 0e 20 01 	ldub  [ %i0 + 1 ], %g3                         <== NOT EXECUTED
40006ac4:	86 08 e0 03 	and  %g3, 3, %g3                               <== NOT EXECUTED
40006ac8:	80 a0 e0 02 	cmp  %g3, 2                                    <== NOT EXECUTED
40006acc:	22 80 00 02 	be,a   40006ad4 <oproc+0x68>                   <== NOT EXECUTED
40006ad0:	84 00 bf e0 	add  %g2, -32, %g2                             <== NOT EXECUTED
40006ad4:	c4 2f a0 44 	stb  %g2, [ %fp + 0x44 ]                       <== NOT EXECUTED
40006ad8:	b0 08 a0 ff 	and  %g2, 0xff, %i0                            <== NOT EXECUTED
      if (!iscntrl(c))                                                
40006adc:	b0 00 40 18 	add  %g1, %i0, %i0                             
40006ae0:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
40006ae4:	80 88 60 20 	btst  0x20, %g1                                
40006ae8:	12 80 00 06 	bne  40006b00 <oproc+0x94>                     <== NEVER TAKEN
40006aec:	90 07 a0 44 	add  %fp, 0x44, %o0                            
        tty->column++;                                                
40006af0:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        
40006af4:	82 00 60 01 	inc  %g1                                       
40006af8:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        
      break;                                                          
    }                                                                 
  }                                                                   
  rtems_termios_puts (&c, 1, tty);                                    
40006afc:	90 07 a0 44 	add  %fp, 0x44, %o0                            
40006b00:	92 10 20 01 	mov  1, %o1                                    
40006b04:	7f ff ff 8a 	call  4000692c <rtems_termios_puts>            
40006b08:	94 10 00 19 	mov  %i1, %o2                                  
40006b0c:	81 c7 e0 08 	ret                                            
40006b10:	81 e8 00 00 	restore                                        
oproc (unsigned char c, struct rtems_termios_tty *tty)                
{                                                                     
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
    switch (c) {                                                      
40006b14:	12 bf ff e6 	bne  40006aac <oproc+0x40>                     <== NOT EXECUTED
40006b18:	80 88 60 02 	btst  2, %g1                                   <== NOT EXECUTED
      }                                                               
      tty->column += i;                                               
      break;                                                          
                                                                      
    case '\b':                                                        
      if (tty->column > 0)                                            
40006b1c:	c2 06 60 28 	ld  [ %i1 + 0x28 ], %g1                        <== NOT EXECUTED
40006b20:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40006b24:	04 bf ff f6 	ble  40006afc <oproc+0x90>                     <== NOT EXECUTED
40006b28:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
      if (!iscntrl(c))                                                
        tty->column++;                                                
      break;                                                          
    }                                                                 
  }                                                                   
  rtems_termios_puts (&c, 1, tty);                                    
40006b2c:	90 07 a0 44 	add  %fp, 0x44, %o0                            <== NOT EXECUTED
      tty->column += i;                                               
      break;                                                          
                                                                      
    case '\b':                                                        
      if (tty->column > 0)                                            
        tty->column--;                                                
40006b30:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        <== NOT EXECUTED
      if (!iscntrl(c))                                                
        tty->column++;                                                
      break;                                                          
    }                                                                 
  }                                                                   
  rtems_termios_puts (&c, 1, tty);                                    
40006b34:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40006b38:	7f ff ff 7d 	call  4000692c <rtems_termios_puts>            <== NOT EXECUTED
40006b3c:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
40006b40:	30 80 00 1b 	b,a   40006bac <oproc+0x140>                   <== NOT EXECUTED
  int  i;                                                             
                                                                      
  if (tty->termios.c_oflag & OPOST) {                                 
    switch (c) {                                                      
    case '\n':                                                        
      if (tty->termios.c_oflag & ONLRET)                              
40006b44:	80 88 60 20 	btst  0x20, %g1                                
40006b48:	32 80 00 02 	bne,a   40006b50 <oproc+0xe4>                  <== NEVER TAKEN
40006b4c:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
        tty->column = 0;                                              
      if (tty->termios.c_oflag & ONLCR) {                             
40006b50:	80 88 60 04 	btst  4, %g1                                   
40006b54:	22 bf ff eb 	be,a   40006b00 <oproc+0x94>                   <== NEVER TAKEN
40006b58:	90 07 a0 44 	add  %fp, 0x44, %o0                            <== NOT EXECUTED
        rtems_termios_puts ("\r", 1, tty);                            
40006b5c:	92 10 20 01 	mov  1, %o1                                    
40006b60:	11 10 00 78 	sethi  %hi(0x4001e000), %o0                    
40006b64:	94 10 00 19 	mov  %i1, %o2                                  
40006b68:	7f ff ff 71 	call  4000692c <rtems_termios_puts>            
40006b6c:	90 12 21 38 	or  %o0, 0x138, %o0                            
        tty->column = 0;                                              
40006b70:	10 bf ff e3 	b  40006afc <oproc+0x90>                       
40006b74:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            
      }                                                               
      tty->column = 0;                                                
      break;                                                          
                                                                      
    case '\t':                                                        
      i = 8 - (tty->column & 7);                                      
40006b78:	92 10 20 08 	mov  8, %o1                                    
40006b7c:	88 08 e0 07 	and  %g3, 7, %g4                               
40006b80:	92 22 40 04 	sub  %o1, %g4, %o1                             
      if ((tty->termios.c_oflag & TABDLY) == XTABS) {                 
        tty->column += i;                                             
40006b84:	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) {                 
40006b88:	05 00 00 06 	sethi  %hi(0x1800), %g2                        
40006b8c:	82 08 40 02 	and  %g1, %g2, %g1                             
40006b90:	80 a0 40 02 	cmp  %g1, %g2                                  
40006b94:	12 bf ff da 	bne  40006afc <oproc+0x90>                     <== NEVER TAKEN
40006b98:	c6 26 60 28 	st  %g3, [ %i1 + 0x28 ]                        
        tty->column += i;                                             
        rtems_termios_puts ( "        ",  i, tty);                    
40006b9c:	11 10 00 78 	sethi  %hi(0x4001e000), %o0                    
40006ba0:	94 10 00 19 	mov  %i1, %o2                                  
40006ba4:	7f ff ff 62 	call  4000692c <rtems_termios_puts>            
40006ba8:	90 12 21 40 	or  %o0, 0x140, %o0                            
        return;                                                       
40006bac:	81 c7 e0 08 	ret                                            
40006bb0:	81 e8 00 00 	restore                                        
        tty->column = 0;                                              
      }                                                               
      break;                                                          
                                                                      
    case '\r':                                                        
      if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))       
40006bb4:	02 80 00 06 	be  40006bcc <oproc+0x160>                     <== NOT EXECUTED
40006bb8:	80 88 60 08 	btst  8, %g1                                   <== NOT EXECUTED
40006bbc:	c4 06 60 28 	ld  [ %i1 + 0x28 ], %g2                        <== NOT EXECUTED
40006bc0:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40006bc4:	02 bf ff d2 	be  40006b0c <oproc+0xa0>                      <== NOT EXECUTED
40006bc8:	80 88 60 08 	btst  8, %g1                                   <== NOT EXECUTED
        return;                                                       
      if (tty->termios.c_oflag & OCRNL) {                             
40006bcc:	22 bf ff cc 	be,a   40006afc <oproc+0x90>                   <== NOT EXECUTED
40006bd0:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
        c = '\n';                                                     
40006bd4:	84 10 20 0a 	mov  0xa, %g2                                  <== NOT EXECUTED
        if (tty->termios.c_oflag & ONLRET)                            
40006bd8:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
40006bdc:	02 bf ff c8 	be  40006afc <oproc+0x90>                      <== NOT EXECUTED
40006be0:	c4 2f a0 44 	stb  %g2, [ %fp + 0x44 ]                       <== NOT EXECUTED
          tty->column = 0;                                            
        break;                                                        
      }                                                               
      tty->column = 0;                                                
      break;                                                          
40006be4:	10 bf ff c6 	b  40006afc <oproc+0x90>                       <== NOT EXECUTED
40006be8:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            <== NOT EXECUTED
                                                                      

40005644 <partition_free>: * RETURNS: * N/A */ static void partition_free(rtems_part_desc_t *part_desc) {
40005644:	9d e3 bf a0 	save  %sp, -96, %sp                            
    int part_num;                                                     
                                                                      
    if (part_desc == NULL)                                            
40005648:	80 a6 20 00 	cmp  %i0, 0                                    
4000564c:	02 80 00 11 	be  40005690 <partition_free+0x4c>             
40005650:	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));
40005654:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
    int part_num;                                                     
                                                                      
    if (part_desc == NULL)                                            
        return;                                                       
                                                                      
    if (is_extended(part_desc->sys_type))                             
40005658:	82 08 60 7f 	and  %g1, 0x7f, %g1                            
4000565c:	80 a0 60 05 	cmp  %g1, 5                                    
40005660:	12 80 00 0a 	bne  40005688 <partition_free+0x44>            <== ALWAYS TAKEN
40005664:	01 00 00 00 	nop                                            
40005668:	ba 10 20 00 	clr  %i5	! 0 <PROM_START>                      <== NOT EXECUTED
 *                                                                    
 * RETURNS:                                                           
 *      N/A                                                           
 */                                                                   
static void                                                           
partition_free(rtems_part_desc_t *part_desc)                          
4000566c:	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]);            
40005670:	d0 00 60 18 	ld  [ %g1 + 0x18 ], %o0                        <== NOT EXECUTED
40005674:	7f ff ff f4 	call  40005644 <partition_free>                <== NOT EXECUTED
40005678:	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;                                            
4000567c:	80 a7 60 10 	cmp  %i5, 0x10                                 <== NOT EXECUTED
40005680:	12 bf ff fc 	bne  40005670 <partition_free+0x2c>            <== NOT EXECUTED
40005684:	82 06 00 1d 	add  %i0, %i5, %g1                             <== NOT EXECUTED
        {                                                             
            partition_free(part_desc->sub_part[part_num]);            
        }                                                             
    }                                                                 
                                                                      
    free(part_desc);                                                  
40005688:	40 00 03 b4 	call  40006558 <free>                          
4000568c:	81 e8 00 00 	restore                                        
40005690:	81 c7 e0 08 	ret                                            
40005694:	81 e8 00 00 	restore                                        
                                                                      

400059dc <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) {
400059dc:	9d e3 bf 50 	save  %sp, -176, %sp                           
    struct stat         dev_stat;                                     
    rtems_status_code   rc;                                           
    int                 fd;                                           
                                                                      
    fd = open(dev_name, O_RDONLY);                                    
400059e0:	92 10 20 00 	clr  %o1                                       
400059e4:	90 10 00 18 	mov  %i0, %o0                                  
400059e8:	40 00 06 8e 	call  40007420 <open>                          
400059ec:	b8 10 00 18 	mov  %i0, %i4                                  
    if (fd < 0)                                                       
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
400059f0:	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)                                                       
400059f4:	80 a2 20 00 	cmp  %o0, 0                                    
400059f8:	06 80 00 09 	bl  40005a1c <partition_table_get+0x40>        <== NEVER TAKEN
400059fc:	ba 10 00 08 	mov  %o0, %i5                                  
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    rc = fstat(fd, &dev_stat);                                        
40005a00:	40 00 03 00 	call  40006600 <fstat>                         
40005a04:	92 07 bf b8 	add  %fp, -72, %o1                             
    if (rc != RTEMS_SUCCESSFUL)                                       
40005a08:	80 a2 20 00 	cmp  %o0, 0                                    
40005a0c:	02 80 00 06 	be  40005a24 <partition_table_get+0x48>        <== ALWAYS TAKEN
40005a10:	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);                                                        
40005a14:	40 00 02 af 	call  400064d0 <close>                         
40005a18:	90 10 00 1d 	mov  %i5, %o0                                  
40005a1c:	81 c7 e0 08 	ret                                            
40005a20:	81 e8 00 00 	restore                                        
    {                                                                 
        close(fd);                                                    
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    strncpy (disk_desc->dev_name, dev_name, 15);                      
40005a24:	92 10 00 1c 	mov  %i4, %o1                                  
40005a28:	40 00 47 c1 	call  4001792c <strncpy>                       
40005a2c:	94 10 20 0f 	mov  0xf, %o2                                  
    disk_desc->dev = dev_stat.st_rdev;                                
40005a30:	c4 1f bf d0 	ldd  [ %fp + -48 ], %g2                        
    disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
40005a34:	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;                                
40005a38:	c4 3e 40 00 	std  %g2, [ %i1 ]                              
    disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
40005a3c:	80 a1 20 00 	cmp  %g4, 0                                    
40005a40:	02 80 00 03 	be  40005a4c <partition_table_get+0x70>        <== ALWAYS TAKEN
40005a44:	82 10 22 00 	mov  0x200, %g1                                
40005a48:	82 10 00 04 	mov  %g4, %g1                                  <== NOT EXECUTED
40005a4c:	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;                               
40005a50:	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);                               
40005a54:	90 10 00 1d 	mov  %i5, %o0                                  
40005a58:	92 10 20 00 	clr  %o1                                       
40005a5c:	94 10 20 00 	clr  %o2                                       
40005a60:	96 10 20 00 	clr  %o3                                       
40005a64:	40 00 03 e1 	call  400069e8 <lseek>                         
40005a68:	b0 10 20 1b 	mov  0x1b, %i0                                 
    if (new_off != off) {                                             
40005a6c:	80 92 00 09 	orcc  %o0, %o1, %g0                            
40005a70:	02 80 00 09 	be  40005a94 <partition_table_get+0xb8>        <== ALWAYS TAKEN
40005a74:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    /* get MBR sector */                                              
    rc = get_sector(fd, 0, §or);                                  
    if (rc != RTEMS_SUCCESSFUL)                                       
    {                                                                 
        if (sector)                                                   
40005a78:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         <== NOT EXECUTED
40005a7c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40005a80:	02 bf ff e5 	be  40005a14 <partition_table_get+0x38>        <== NOT EXECUTED
40005a84:	01 00 00 00 	nop                                            <== NOT EXECUTED
         part_num++)                                                  
    {                                                                 
        rc = data_to_part_desc(data, &part_desc);                     
        if (rc != RTEMS_SUCCESSFUL)                                   
        {                                                             
            free(sector);                                             
40005a88:	40 00 02 b4 	call  40006558 <free>                          <== NOT EXECUTED
40005a8c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40005a90:	30 bf ff e1 	b,a   40005a14 <partition_table_get+0x38>      <== NOT EXECUTED
40005a94:	92 10 20 00 	clr  %o1	! 0 <PROM_START>                      
40005a98:	7f ff ff 0b 	call  400056c4 <get_sector.part.0>             
40005a9c:	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)                                       
40005aa0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40005aa4:	12 bf ff f5 	bne  40005a78 <partition_table_get+0x9c>       <== NEVER TAKEN
40005aa8:	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) &&    
40005aac:	c2 0a 22 02 	ldub  [ %o0 + 0x202 ], %g1                     
40005ab0:	80 a0 60 55 	cmp  %g1, 0x55                                 
40005ab4:	22 80 00 05 	be,a   40005ac8 <partition_table_get+0xec>     <== ALWAYS TAKEN
40005ab8:	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);                                                 
40005abc:	40 00 02 a7 	call  40006558 <free>                          <== NOT EXECUTED
40005ac0:	b0 10 20 19 	mov  0x19, %i0                                 <== NOT EXECUTED
40005ac4:	30 bf ff d4 	b,a   40005a14 <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) &&    
40005ac8:	80 a0 60 aa 	cmp  %g1, 0xaa                                 
40005acc:	12 bf ff fc 	bne  40005abc <partition_table_get+0xe0>       <== NEVER TAKEN
40005ad0:	b4 02 21 c2 	add  %o0, 0x1c2, %i2                           
40005ad4:	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;           
40005ad8:	a0 10 00 19 	mov  %i1, %l0                                  
40005adc:	b8 10 20 01 	mov  1, %i4                                    
40005ae0:	90 10 00 1a 	mov  %i2, %o0                                  
40005ae4:	7f ff ff 0f 	call  40005720 <data_to_part_desc.part.1>      
40005ae8:	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)                                   
40005aec:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40005af0:	12 80 00 2b 	bne  40005b9c <partition_table_get+0x1c0>      <== NEVER TAKEN
40005af4:	c2 07 bf b4 	ld  [ %fp + -76 ], %g1                         
        {                                                             
            free(sector);                                             
            return rc;                                                
        }                                                             
                                                                      
        if (part_desc != NULL)                                        
40005af8:	80 a0 60 00 	cmp  %g1, 0                                    
40005afc:	22 80 00 0a 	be,a   40005b24 <partition_table_get+0x148>    <== NEVER TAKEN
40005b00:	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;  
40005b04:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
40005b08:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
            return rc;                                                
        }                                                             
                                                                      
        if (part_desc != NULL)                                        
        {                                                             
            part_desc->log_id = part_num + 1;                         
40005b0c:	f8 28 60 02 	stb  %i4, [ %g1 + 2 ]                          
            part_desc->disk_desc = disk_desc;                         
40005b10:	f2 20 60 10 	st  %i1, [ %g1 + 0x10 ]                        
            part_desc->end = part_desc->start + part_desc->size - 1;  
40005b14:	84 00 c0 02 	add  %g3, %g2, %g2                             
40005b18:	84 00 bf ff 	add  %g2, -1, %g2                              
40005b1c:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
            disk_desc->partitions[part_num] = part_desc;              
40005b20:	c2 24 20 28 	st  %g1, [ %l0 + 0x28 ]                        
40005b24:	b8 07 20 01 	inc  %i4                                       
        else                                                          
        {                                                             
            disk_desc->partitions[part_num] = NULL;                   
        }                                                             
                                                                      
        data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;                  
40005b28:	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;                                                
40005b2c:	82 0f 20 ff 	and  %i4, 0xff, %g1                            
40005b30:	80 a0 60 05 	cmp  %g1, 5                                    
40005b34:	12 bf ff eb 	bne  40005ae0 <partition_table_get+0x104>      
40005b38:	a0 04 20 04 	add  %l0, 4, %l0                               
        }                                                             
                                                                      
        data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;                  
    }                                                                 
                                                                      
    free(sector);                                                     
40005b3c:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         
40005b40:	40 00 02 86 	call  40006558 <free>                          
40005b44:	b8 10 20 04 	mov  4, %i4                                    
                                                                      
    disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
40005b48:	82 10 20 04 	mov  4, %g1                                    
40005b4c:	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];                  
40005b50:	d4 06 e0 28 	ld  [ %i3 + 0x28 ], %o2                        
        if (part_desc != NULL && is_extended(part_desc->sys_type))    
40005b54:	80 a2 a0 00 	cmp  %o2, 0                                    
40005b58:	02 80 00 07 	be  40005b74 <partition_table_get+0x198>       <== NEVER TAKEN
40005b5c:	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));
40005b60:	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))    
40005b64:	82 08 60 7f 	and  %g1, 0x7f, %g1                            
40005b68:	80 a0 60 05 	cmp  %g1, 5                                    
40005b6c:	22 80 00 06 	be,a   40005b84 <partition_table_get+0x1a8>    
40005b70:	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;                                                
40005b74:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
40005b78:	12 bf ff f6 	bne  40005b50 <partition_table_get+0x174>      
40005b7c:	b6 06 e0 04 	add  %i3, 4, %i3                               
40005b80:	30 bf ff a5 	b,a   40005a14 <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); 
40005b84:	7f ff ff 34 	call  40005854 <read_extended_partition>       
40005b88:	90 10 00 1d 	mov  %i5, %o0                                  
            free(part_desc);                                          
40005b8c:	40 00 02 73 	call  40006558 <free>                          
40005b90:	d0 07 bf b4 	ld  [ %fp + -76 ], %o0                         
            disk_desc->partitions[part_num] = NULL;                   
40005b94:	10 bf ff f8 	b  40005b74 <partition_table_get+0x198>        
40005b98:	c0 26 e0 28 	clr  [ %i3 + 0x28 ]                            
         part_num++)                                                  
    {                                                                 
        rc = data_to_part_desc(data, &part_desc);                     
        if (rc != RTEMS_SUCCESSFUL)                                   
        {                                                             
            free(sector);                                             
40005b9c:	40 00 02 6f 	call  40006558 <free>                          <== NOT EXECUTED
40005ba0:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         <== NOT EXECUTED
40005ba4:	30 bf ff 9c 	b,a   40005a14 <partition_table_get+0x38>      <== NOT EXECUTED
                                                                      

4000556c <pathconf>: */ long pathconf( const char *path, int name ) {
4000556c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int status;                                                         
  int fd;                                                             
                                                                      
  fd = open( path, O_RDONLY );                                        
40005570:	92 10 20 00 	clr  %o1                                       
40005574:	7f ff ff 6d 	call  40005328 <open>                          
40005578:	90 10 00 18 	mov  %i0, %o0                                  
  if ( fd == -1 )                                                     
4000557c:	80 a2 3f ff 	cmp  %o0, -1                                   
40005580:	02 80 00 09 	be  400055a4 <pathconf+0x38>                   <== ALWAYS TAKEN
40005584:	ba 10 00 08 	mov  %o0, %i5                                  
    return -1;                                                        
                                                                      
  status = fpathconf( fd, name );                                     
40005588:	40 00 15 3b 	call  4000aa74 <fpathconf>                     <== NOT EXECUTED
4000558c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40005590:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
                                                                      
  (void) close( fd );                                                 
40005594:	40 00 15 0a 	call  4000a9bc <close>                         <== NOT EXECUTED
40005598:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  return status;                                                      
4000559c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400055a0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
}                                                                     
400055a4:	81 c7 e0 08 	ret                                            
400055a8:	91 e8 3f ff 	restore  %g0, -1, %o0                          
                                                                      

4000df60 <pipe_create>: static uint16_t rtems_pipe_no = 0; int pipe_create( int filsdes[2] ) {
4000df60:	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)          
4000df64:	92 10 21 ff 	mov  0x1ff, %o1                                
4000df68:	11 10 00 7f 	sethi  %hi(0x4001fc00), %o0                    
4000df6c:	40 00 05 93 	call  4000f5b8 <rtems_mkdir>                   
4000df70:	90 12 22 c0 	or  %o0, 0x2c0, %o0	! 4001fec0 <_CPU_Trap_slot_template+0x10>
4000df74:	80 a2 20 00 	cmp  %o0, 0                                    
4000df78:	12 80 00 49 	bne  4000e09c <pipe_create+0x13c>              
4000df7c:	03 10 00 84 	sethi  %hi(0x40021000), %g1                    
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
4000df80:	d4 10 60 e0 	lduh  [ %g1 + 0xe0 ], %o2	! 400210e0 <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);                                 
4000df84:	05 0b dd 1b 	sethi  %hi(0x2f746c00), %g2                    
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
4000df88:	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);                                 
4000df8c:	84 10 a1 70 	or  %g2, 0x170, %g2                            
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
4000df90:	c8 30 60 e0 	sth  %g4, [ %g1 + 0xe0 ]                       
  if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)          
    return -1;                                                        
                                                                      
  /* /tmp/.fifoXXXX */                                                
  char fifopath[15];                                                  
  memcpy(fifopath, "/tmp/.fifo", 10);                                 
4000df94:	07 0b cb 99 	sethi  %hi(0x2f2e6400), %g3                    
4000df98:	03 00 00 19 	sethi  %hi(0x6400), %g1                        
4000df9c:	86 10 e2 69 	or  %g3, 0x269, %g3                            
4000dfa0:	82 10 62 6f 	or  %g1, 0x26f, %g1                            
4000dfa4:	c4 3f bf f0 	std  %g2, [ %fp + -16 ]                        
4000dfa8:	c2 37 bf f8 	sth  %g1, [ %fp + -8 ]                         
  sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);                   
4000dfac:	95 2a a0 10 	sll  %o2, 0x10, %o2                            
4000dfb0:	90 07 bf fa 	add  %fp, -6, %o0                              
4000dfb4:	95 32 a0 10 	srl  %o2, 0x10, %o2                            
4000dfb8:	13 10 00 7f 	sethi  %hi(0x4001fc00), %o1                    
4000dfbc:	40 00 12 f8 	call  40012b9c <sprintf>                       
4000dfc0:	92 12 62 c8 	or  %o1, 0x2c8, %o1	! 4001fec8 <_CPU_Trap_slot_template+0x18>
                                                                      
  /* Try creating FIFO file until find an available file name */      
  while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {                    
4000dfc4:	90 07 bf f0 	add  %fp, -16, %o0                             
4000dfc8:	40 00 04 c8 	call  4000f2e8 <mkfifo>                        
4000dfcc:	92 10 21 80 	mov  0x180, %o1                                
4000dfd0:	80 a2 20 00 	cmp  %o0, 0                                    
4000dfd4:	12 80 00 39 	bne  4000e0b8 <pipe_create+0x158>              <== NEVER TAKEN
4000dfd8:	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);                 
4000dfdc:	7f ff dd c8 	call  400056fc <open>                          
4000dfe0:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
  if (filsdes[0] < 0) {                                               
4000dfe4:	80 a2 20 00 	cmp  %o0, 0                                    
4000dfe8:	06 80 00 20 	bl  4000e068 <pipe_create+0x108>               
4000dfec:	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]);                                
4000dff0:	03 10 00 82 	sethi  %hi(0x40020800), %g1                    
4000dff4:	c4 00 60 54 	ld  [ %g1 + 0x54 ], %g2	! 40020854 <rtems_libio_number_iops>
4000dff8:	80 a2 00 02 	cmp  %o0, %g2                                  
4000dffc:	0a 80 00 14 	bcs  4000e04c <pipe_create+0xec>               <== ALWAYS TAKEN
4000e000:	82 10 20 00 	clr  %g1                                       
    iop->flags &= ~LIBIO_FLAGS_NO_DELAY;                              
4000e004:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
4000e008:	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;                              
4000e00c:	84 08 bf fe 	and  %g2, -2, %g2                              
                                                                      
    filsdes[1] = open(fifopath, O_WRONLY);                            
4000e010:	92 10 20 01 	mov  1, %o1                                    
4000e014:	7f ff dd ba 	call  400056fc <open>                          
4000e018:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
4000e01c:	d0 26 20 04 	st  %o0, [ %i0 + 4 ]                           
                                                                      
    if (filsdes[1] < 0) {                                             
4000e020:	80 a2 20 00 	cmp  %o0, 0                                    
4000e024:	06 80 00 18 	bl  4000e084 <pipe_create+0x124>               
4000e028:	ba 10 20 00 	clr  %i5                                       
    err = errno;                                                      
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
4000e02c:	7f ff e9 c4 	call  4000873c <unlink>                        
4000e030:	90 07 bf f0 	add  %fp, -16, %o0                             
  }                                                                   
  if(err != 0)                                                        
    rtems_set_errno_and_return_minus_one(err);                        
  return 0;                                                           
4000e034:	b0 10 20 00 	clr  %i0                                       
    err = errno;                                                      
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
4000e038:	80 a7 60 00 	cmp  %i5, 0                                    
4000e03c:	12 80 00 1a 	bne  4000e0a4 <pipe_create+0x144>              
4000e040:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one(err);                        
  return 0;                                                           
}                                                                     
4000e044:	81 c7 e0 08 	ret                                            
4000e048:	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]);                                
4000e04c:	03 10 00 84 	sethi  %hi(0x40021000), %g1                    
4000e050:	c2 00 63 c8 	ld  [ %g1 + 0x3c8 ], %g1	! 400213c8 <rtems_libio_iops>
4000e054:	85 2a 20 03 	sll  %o0, 3, %g2                               
4000e058:	91 2a 20 06 	sll  %o0, 6, %o0                               
4000e05c:	90 22 00 02 	sub  %o0, %g2, %o0                             
4000e060:	10 bf ff e9 	b  4000e004 <pipe_create+0xa4>                 
4000e064:	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;                                                      
4000e068:	40 00 0f fb 	call  40012054 <__errno>                       
4000e06c:	b0 10 20 00 	clr  %i0                                       
4000e070:	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);                                                 
4000e074:	7f ff e9 b2 	call  4000873c <unlink>                        
4000e078:	90 07 bf f0 	add  %fp, -16, %o0                             
    err = errno;                                                      
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
4000e07c:	10 bf ff f0 	b  4000e03c <pipe_create+0xdc>                 
4000e080:	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;                                                      
4000e084:	40 00 0f f4 	call  40012054 <__errno>                       
4000e088:	01 00 00 00 	nop                                            
4000e08c:	fa 02 00 00 	ld  [ %o0 ], %i5                               
    close(filsdes[0]);                                                
4000e090:	7f ff da 39 	call  40004974 <close>                         
4000e094:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000e098:	30 bf ff e5 	b,a   4000e02c <pipe_create+0xcc>              
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
    rtems_set_errno_and_return_minus_one(err);                        
  return 0;                                                           
}                                                                     
4000e09c:	81 c7 e0 08 	ret                                            
4000e0a0:	91 e8 3f ff 	restore  %g0, -1, %o0                          
    close(filsdes[0]);                                                
    }                                                                 
  unlink(fifopath);                                                   
  }                                                                   
  if(err != 0)                                                        
    rtems_set_errno_and_return_minus_one(err);                        
4000e0a4:	40 00 0f ec 	call  40012054 <__errno>                       
4000e0a8:	b0 10 3f ff 	mov  -1, %i0                                   
4000e0ac:	fa 22 00 00 	st  %i5, [ %o0 ]                               
4000e0b0:	81 c7 e0 08 	ret                                            
4000e0b4:	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){                                             
4000e0b8:	40 00 0f e7 	call  40012054 <__errno>                       <== NOT EXECUTED
4000e0bc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000e0c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e0c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000f578 <pipe_ioctl>: pipe_control_t *pipe, ioctl_command_t cmd, void *buffer, rtems_libio_t *iop ) {
4000f578:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (cmd == FIONREAD) {                                              
4000f57c:	03 10 01 19 	sethi  %hi(0x40046400), %g1                    
4000f580:	82 10 62 7f 	or  %g1, 0x27f, %g1	! 4004667f <__end+0x20bbf> 
4000f584:	80 a6 40 01 	cmp  %i1, %g1                                  
4000f588:	12 80 00 11 	bne  4000f5cc <pipe_ioctl+0x54>                
4000f58c:	80 a6 a0 00 	cmp  %i2, 0                                    
    if (buffer == NULL)                                               
4000f590:	02 80 00 13 	be  4000f5dc <pipe_ioctl+0x64>                 
4000f594:	92 10 20 00 	clr  %o1                                       
      return -EFAULT;                                                 
                                                                      
    if (! PIPE_LOCK(pipe))                                            
4000f598:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
4000f59c:	7f ff e9 ba 	call  40009c84 <rtems_semaphore_obtain>        
4000f5a0:	94 10 20 00 	clr  %o2                                       
4000f5a4:	80 a2 20 00 	cmp  %o0, 0                                    
4000f5a8:	12 80 00 0b 	bne  4000f5d4 <pipe_ioctl+0x5c>                <== NEVER TAKEN
4000f5ac:	01 00 00 00 	nop                                            
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
4000f5b0:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
    PIPE_UNLOCK(pipe);                                                
4000f5b4:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
                                                                      
    if (! PIPE_LOCK(pipe))                                            
      return -EINTR;                                                  
                                                                      
    /* Return length of pipe */                                       
    *(unsigned int *)buffer = pipe->Length;                           
4000f5b8:	c2 26 80 00 	st  %g1, [ %i2 ]                               
    PIPE_UNLOCK(pipe);                                                
4000f5bc:	7f ff ea 01 	call  40009dc0 <rtems_semaphore_release>       
4000f5c0:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
4000f5c4:	81 c7 e0 08 	ret                                            
4000f5c8:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  return -EINVAL;                                                     
4000f5cc:	81 c7 e0 08 	ret                                            
4000f5d0:	91 e8 3f ea 	restore  %g0, -22, %o0                         
}                                                                     
4000f5d4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f5d8:	91 e8 3f fc 	restore  %g0, -4, %o0                          <== NOT EXECUTED
  rtems_libio_t   *iop                                                
)                                                                     
{                                                                     
  if (cmd == FIONREAD) {                                              
    if (buffer == NULL)                                               
      return -EFAULT;                                                 
4000f5dc:	81 c7 e0 08 	ret                                            
4000f5e0:	91 e8 3f f2 	restore  %g0, -14, %o0                         
                                                                      

4000f1b4 <pipe_read>: pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) {
4000f1b4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
4000f1b8:	d0 06 20 28 	ld  [ %i0 + 0x28 ], %o0                        
4000f1bc:	92 10 20 00 	clr  %o1                                       
4000f1c0:	94 10 20 00 	clr  %o2                                       
4000f1c4:	7f ff ea b0 	call  40009c84 <rtems_semaphore_obtain>        
4000f1c8:	ba 10 00 18 	mov  %i0, %i5                                  
4000f1cc:	80 a2 20 00 	cmp  %o0, 0                                    
4000f1d0:	12 80 00 60 	bne  4000f350 <pipe_read+0x19c>                <== NEVER TAKEN
4000f1d4:	a0 10 20 00 	clr  %l0                                       
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
4000f1d8:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f1dc:	02 80 00 53 	be  4000f328 <pipe_read+0x174>                 <== NEVER TAKEN
4000f1e0:	b0 10 20 00 	clr  %i0                                       
    while (PIPE_EMPTY(pipe)) {                                        
4000f1e4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4000f1e8:	80 a0 60 00 	cmp  %g1, 0                                    
4000f1ec:	12 80 00 29 	bne  4000f290 <pipe_read+0xdc>                 
4000f1f0:	84 26 80 10 	sub  %i2, %l0, %g2                             
      /* Not an error */                                              
      if (pipe->Writers == 0)                                         
4000f1f4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4000f1f8:	80 a0 60 00 	cmp  %g1, 0                                    
4000f1fc:	02 80 00 1c 	be  4000f26c <pipe_read+0xb8>                  
4000f200:	b8 10 20 00 	clr  %i4                                       
        goto out_locked;                                              
                                                                      
      if (LIBIO_NODELAY(iop)) {                                       
4000f204:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
4000f208:	80 88 60 01 	btst  1, %g1                                   
4000f20c:	32 80 00 18 	bne,a   4000f26c <pipe_read+0xb8>              
4000f210:	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 ++;                                        
4000f214:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
      PIPE_UNLOCK(pipe);                                              
4000f218:	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 ++;                                        
4000f21c:	82 00 60 01 	inc  %g1                                       
      PIPE_UNLOCK(pipe);                                              
4000f220:	7f ff ea e8 	call  40009dc0 <rtems_semaphore_release>       
4000f224:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
      if (! PIPE_READWAIT(pipe))                                      
4000f228:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000f22c:	40 00 05 c8 	call  4001094c <rtems_barrier_wait>            
4000f230:	92 10 20 00 	clr  %o1                                       
4000f234:	80 a0 00 08 	cmp  %g0, %o0                                  
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
4000f238:	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))                                      
4000f23c:	b8 60 20 00 	subx  %g0, 0, %i4                              
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
4000f240:	92 10 20 00 	clr  %o1                                       
4000f244:	94 10 20 00 	clr  %o2                                       
4000f248:	7f ff ea 8f 	call  40009c84 <rtems_semaphore_obtain>        
4000f24c:	b8 0f 3f fc 	and  %i4, -4, %i4                              
4000f250:	80 a2 20 00 	cmp  %o0, 0                                    
4000f254:	12 80 00 37 	bne  4000f330 <pipe_read+0x17c>                <== NEVER TAKEN
4000f258:	80 a7 20 00 	cmp  %i4, 0                                    
        /* WARN waitingReaders not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingReaders --;                                        
4000f25c:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
4000f260:	82 00 7f ff 	add  %g1, -1, %g1                              
      if (ret != 0)                                                   
4000f264:	02 bf ff e0 	be  4000f1e4 <pipe_read+0x30>                  <== ALWAYS TAKEN
4000f268:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
      PIPE_WAKEUPWRITERS(pipe);                                       
    read += chunk;                                                    
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
4000f26c:	7f ff ea d5 	call  40009dc0 <rtems_semaphore_release>       
4000f270:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
out_nolock:                                                           
  if (read > 0)                                                       
4000f274:	80 a6 20 00 	cmp  %i0, 0                                    
4000f278:	04 80 00 04 	ble  4000f288 <pipe_read+0xd4>                 
4000f27c:	01 00 00 00 	nop                                            
    return read;                                                      
  return ret;                                                         
}                                                                     
4000f280:	81 c7 e0 08 	ret                                            
4000f284:	81 e8 00 00 	restore                                        
4000f288:	81 c7 e0 08 	ret                                            
4000f28c:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
      if (ret != 0)                                                   
        goto out_locked;                                              
    }                                                                 
                                                                      
    /* Read chunk bytes */                                            
    chunk = MIN(count - read,  pipe->Length);                         
4000f290:	80 a0 40 02 	cmp  %g1, %g2                                  
4000f294:	08 80 00 03 	bleu  4000f2a0 <pipe_read+0xec>                
4000f298:	b8 10 00 01 	mov  %g1, %i4                                  
4000f29c:	b8 10 00 02 	mov  %g2, %i4                                  
    chunk1 = pipe->Size - pipe->Start;                                
4000f2a0:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
4000f2a4:	e2 07 60 04 	ld  [ %i5 + 4 ], %l1                           
4000f2a8:	a2 24 40 01 	sub  %l1, %g1, %l1                             
    if (chunk > chunk1) {                                             
4000f2ac:	80 a7 00 11 	cmp  %i4, %l1                                  
4000f2b0:	04 80 00 22 	ble  4000f338 <pipe_read+0x184>                
4000f2b4:	d2 07 40 00 	ld  [ %i5 ], %o1                               
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);      
4000f2b8:	94 10 00 11 	mov  %l1, %o2                                  
4000f2bc:	92 02 40 01 	add  %o1, %g1, %o1                             
4000f2c0:	40 00 11 51 	call  40013804 <memcpy>                        
4000f2c4:	90 06 40 10 	add  %i1, %l0, %o0                             
      memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);   
4000f2c8:	d2 07 40 00 	ld  [ %i5 ], %o1                               
4000f2cc:	90 04 00 11 	add  %l0, %l1, %o0                             
4000f2d0:	94 27 00 11 	sub  %i4, %l1, %o2                             
4000f2d4:	40 00 11 4c 	call  40013804 <memcpy>                        
4000f2d8:	90 06 40 08 	add  %i1, %o0, %o0                             
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
                                                                      
    pipe->Start += chunk;                                             
4000f2dc:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
    pipe->Start %= pipe->Size;                                        
4000f2e0:	d2 07 60 04 	ld  [ %i5 + 4 ], %o1                           
4000f2e4:	40 00 40 4f 	call  4001f420 <.urem>                         
4000f2e8:	90 07 00 08 	add  %i4, %o0, %o0                             
    pipe->Length -= chunk;                                            
4000f2ec:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    }                                                                 
    else                                                              
      memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);       
                                                                      
    pipe->Start += chunk;                                             
    pipe->Start %= pipe->Size;                                        
4000f2f0:	d0 27 60 08 	st  %o0, [ %i5 + 8 ]                           
    pipe->Length -= chunk;                                            
4000f2f4:	82 20 40 1c 	sub  %g1, %i4, %g1                             
    /* For buffering optimization */                                  
    if (PIPE_EMPTY(pipe))                                             
4000f2f8:	80 a0 60 00 	cmp  %g1, 0                                    
4000f2fc:	12 80 00 03 	bne  4000f308 <pipe_read+0x154>                
4000f300:	c2 27 60 0c 	st  %g1, [ %i5 + 0xc ]                         
      pipe->Start = 0;                                                
4000f304:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
                                                                      
    if (pipe->waitingWriters > 0)                                     
4000f308:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
4000f30c:	80 a0 60 00 	cmp  %g1, 0                                    
4000f310:	32 80 00 12 	bne,a   4000f358 <pipe_read+0x1a4>             
4000f314:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
      PIPE_WAKEUPWRITERS(pipe);                                       
    read += chunk;                                                    
4000f318:	b0 06 00 1c 	add  %i0, %i4, %i0                             
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
                                                                      
  while (read < count) {                                              
4000f31c:	80 a6 00 1a 	cmp  %i0, %i2                                  
4000f320:	0a bf ff b1 	bcs  4000f1e4 <pipe_read+0x30>                 <== NEVER TAKEN
4000f324:	a0 10 00 18 	mov  %i0, %l0                                  
    while (PIPE_EMPTY(pipe)) {                                        
      /* Not an error */                                              
      if (pipe->Writers == 0)                                         
4000f328:	10 bf ff d1 	b  4000f26c <pipe_read+0xb8>                   
4000f32c:	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;                                                 
4000f330:	10 bf ff d1 	b  4000f274 <pipe_read+0xc0>                   <== NOT EXECUTED
4000f334:	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);       
4000f338:	90 06 40 10 	add  %i1, %l0, %o0                             
4000f33c:	92 02 40 01 	add  %o1, %g1, %o1                             
4000f340:	40 00 11 31 	call  40013804 <memcpy>                        
4000f344:	94 10 00 1c 	mov  %i4, %o2                                  
                                                                      
    pipe->Start += chunk;                                             
4000f348:	10 bf ff e6 	b  4000f2e0 <pipe_read+0x12c>                  
4000f34c:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
)                                                                     
{                                                                     
  int chunk, chunk1, read = 0, ret = 0;                               
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
4000f350:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f354:	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);                                       
4000f358:	40 00 05 65 	call  400108ec <rtems_barrier_release>         
4000f35c:	92 07 bf fc 	add  %fp, -4, %o1                              
    read += chunk;                                                    
4000f360:	10 bf ff ef 	b  4000f31c <pipe_read+0x168>                  
4000f364:	b0 06 00 1c 	add  %i0, %i4, %i0                             
                                                                      

4000ec04 <pipe_release>: void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) {
4000ec04:	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);                                          
4000ec08:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
void pipe_release(                                                    
  pipe_control_t **pipep,                                             
  rtems_libio_t *iop                                                  
)                                                                     
{                                                                     
  pipe_control_t *pipe = *pipep;                                      
4000ec0c:	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)                                        
4000ec10:	80 88 60 02 	btst  2, %g1                                   
4000ec14:	02 80 00 05 	be  4000ec28 <pipe_release+0x24>               
4000ec18:	b8 08 60 06 	and  %g1, 6, %i4                               
     pipe->Readers --;                                                
4000ec1c:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
4000ec20:	84 00 bf ff 	add  %g2, -1, %g2                              
4000ec24:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        
  if (mode & LIBIO_FLAGS_WRITE)                                       
4000ec28:	80 88 60 04 	btst  4, %g1                                   
4000ec2c:	02 80 00 05 	be  4000ec40 <pipe_release+0x3c>               
4000ec30:	01 00 00 00 	nop                                            
     pipe->Writers --;                                                
4000ec34:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4000ec38:	82 00 7f ff 	add  %g1, -1, %g1                              
4000ec3c:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
                                                                      
  PIPE_UNLOCK(pipe);                                                  
4000ec40:	7f ff ec 60 	call  40009dc0 <rtems_semaphore_release>       
4000ec44:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
                                                                      
  if (pipe->Readers == 0 && pipe->Writers == 0) {                     
4000ec48:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000ec4c:	80 a0 60 00 	cmp  %g1, 0                                    
4000ec50:	02 80 00 0f 	be  4000ec8c <pipe_release+0x88>               
4000ec54:	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)            
4000ec58:	80 a0 60 00 	cmp  %g1, 0                                    
4000ec5c:	12 80 00 07 	bne  4000ec78 <pipe_release+0x74>              <== NEVER TAKEN
4000ec60:	80 a7 20 02 	cmp  %i4, 2                                    
4000ec64:	02 80 00 06 	be  4000ec7c <pipe_release+0x78>               <== NEVER TAKEN
4000ec68:	03 10 00 92 	sethi  %hi(0x40024800), %g1                    
    PIPE_WAKEUPREADERS(pipe);                                         
4000ec6c:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000ec70:	40 00 07 1f 	call  400108ec <rtems_barrier_release>         
4000ec74:	92 07 bf fc 	add  %fp, -4, %o1                              
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
4000ec78:	03 10 00 92 	sethi  %hi(0x40024800), %g1                    
4000ec7c:	7f ff ec 51 	call  40009dc0 <rtems_semaphore_release>       
4000ec80:	d0 00 63 20 	ld  [ %g1 + 0x320 ], %o0	! 40024b20 <pipe_semaphore>
4000ec84:	81 c7 e0 08 	ret                                            
4000ec88:	81 e8 00 00 	restore                                        
  if (mode & LIBIO_FLAGS_WRITE)                                       
     pipe->Writers --;                                                
                                                                      
  PIPE_UNLOCK(pipe);                                                  
                                                                      
  if (pipe->Readers == 0 && pipe->Writers == 0) {                     
4000ec8c:	80 a0 60 00 	cmp  %g1, 0                                    
4000ec90:	02 80 00 0c 	be  4000ecc0 <pipe_release+0xbc>               
4000ec94:	80 a7 20 04 	cmp  %i4, 4                                    
      delfile = TRUE;                                                 
#endif                                                                
    pipe_free(pipe);                                                  
    *pipep = NULL;                                                    
  }                                                                   
  else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)           
4000ec98:	02 bf ff f9 	be  4000ec7c <pipe_release+0x78>               <== NEVER TAKEN
4000ec9c:	03 10 00 92 	sethi  %hi(0x40024800), %g1                    
    /* Notify waiting Writers that all their partners left */         
    PIPE_WAKEUPWRITERS(pipe);                                         
4000eca0:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000eca4:	40 00 07 12 	call  400108ec <rtems_barrier_release>         
4000eca8:	92 07 bf fc 	add  %fp, -4, %o1                              
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
4000ecac:	03 10 00 92 	sethi  %hi(0x40024800), %g1                    
4000ecb0:	7f ff ec 44 	call  40009dc0 <rtems_semaphore_release>       
4000ecb4:	d0 00 63 20 	ld  [ %g1 + 0x320 ], %o0	! 40024b20 <pipe_semaphore>
4000ecb8:	81 c7 e0 08 	ret                                            
4000ecbc:	81 e8 00 00 	restore                                        
/* Called with pipe_semaphore held. */                                
static inline void pipe_free(                                         
  pipe_control_t *pipe                                                
)                                                                     
{                                                                     
  rtems_barrier_delete(pipe->readBarrier);                            
4000ecc0:	40 00 06 e2 	call  40010848 <rtems_barrier_delete>          
4000ecc4:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
  rtems_barrier_delete(pipe->writeBarrier);                           
4000ecc8:	40 00 06 e0 	call  40010848 <rtems_barrier_delete>          
4000eccc:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
  rtems_semaphore_delete(pipe->Semaphore);                            
4000ecd0:	7f ff eb b6 	call  40009ba8 <rtems_semaphore_delete>        
4000ecd4:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
  free(pipe->Buffer);                                                 
4000ecd8:	7f ff d9 82 	call  400052e0 <free>                          
4000ecdc:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  free(pipe);                                                         
4000ece0:	7f ff d9 80 	call  400052e0 <free>                          
4000ece4:	90 10 00 1d 	mov  %i5, %o0                                  
#ifdef RTEMS_DEBUG                                                    
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  sc =                                                                
#endif                                                                
   rtems_semaphore_release(pipe_semaphore);                           
4000ece8:	03 10 00 92 	sethi  %hi(0x40024800), %g1                    
4000ecec:	d0 00 63 20 	ld  [ %g1 + 0x320 ], %o0	! 40024b20 <pipe_semaphore>
4000ecf0:	7f ff ec 34 	call  40009dc0 <rtems_semaphore_release>       
4000ecf4:	c0 26 00 00 	clr  [ %i0 ]                                   
4000ecf8:	81 c7 e0 08 	ret                                            
4000ecfc:	81 e8 00 00 	restore                                        
                                                                      

4000f368 <pipe_write>: pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) {
4000f368:	9d e3 bf 98 	save  %sp, -104, %sp                           
4000f36c:	ba 10 00 18 	mov  %i0, %i5                                  
  int chunk, chunk1, written = 0, ret = 0;                            
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
4000f370:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f374:	12 80 00 04 	bne  4000f384 <pipe_write+0x1c>                <== ALWAYS TAKEN
4000f378:	b0 10 20 00 	clr  %i0                                       
#endif                                                                
                                                                      
  if (written > 0)                                                    
    return written;                                                   
  return ret;                                                         
}                                                                     
4000f37c:	81 c7 e0 08 	ret                                            
4000f380:	81 e8 00 00 	restore                                        
                                                                      
  /* Write nothing */                                                 
  if (count == 0)                                                     
    return 0;                                                         
                                                                      
  if (! PIPE_LOCK(pipe))                                              
4000f384:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
4000f388:	92 10 20 00 	clr  %o1                                       
4000f38c:	7f ff ea 3e 	call  40009c84 <rtems_semaphore_obtain>        
4000f390:	94 10 20 00 	clr  %o2                                       
4000f394:	80 a2 20 00 	cmp  %o0, 0                                    
4000f398:	12 80 00 6c 	bne  4000f548 <pipe_write+0x1e0>               <== NEVER TAKEN
4000f39c:	01 00 00 00 	nop                                            
    return -EINTR;                                                    
                                                                      
  if (pipe->Readers == 0) {                                           
4000f3a0:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000f3a4:	80 a0 60 00 	cmp  %g1, 0                                    
4000f3a8:	22 80 00 54 	be,a   4000f4f8 <pipe_write+0x190>             
4000f3ac:	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;                            
4000f3b0:	f8 07 60 04 	ld  [ %i5 + 4 ], %i4                           
4000f3b4:	80 a6 80 1c 	cmp  %i2, %i4                                  
4000f3b8:	08 80 00 5b 	bleu  4000f524 <pipe_write+0x1bc>              <== ALWAYS TAKEN
4000f3bc:	a0 10 20 01 	mov  1, %l0                                    
4000f3c0:	a2 10 20 00 	clr  %l1                                       
4000f3c4:	b0 10 20 00 	clr  %i0                                       
                                                                      
  while (written < count) {                                           
    while (PIPE_SPACE(pipe) < chunk) {                                
4000f3c8:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4000f3cc:	84 27 00 01 	sub  %i4, %g1, %g2                             
4000f3d0:	80 a0 80 10 	cmp  %g2, %l0                                  
4000f3d4:	1a 80 00 27 	bcc  4000f470 <pipe_write+0x108>               
4000f3d8:	86 26 80 11 	sub  %i2, %l1, %g3                             
      if (LIBIO_NODELAY(iop)) {                                       
4000f3dc:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
4000f3e0:	80 88 60 01 	btst  1, %g1                                   
4000f3e4:	32 80 00 53 	bne,a   4000f530 <pipe_write+0x1c8>            
4000f3e8:	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 ++;                                        
4000f3ec:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      PIPE_UNLOCK(pipe);                                              
4000f3f0:	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 ++;                                        
4000f3f4:	82 00 60 01 	inc  %g1                                       
      PIPE_UNLOCK(pipe);                                              
4000f3f8:	7f ff ea 72 	call  40009dc0 <rtems_semaphore_release>       
4000f3fc:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
      if (! PIPE_WRITEWAIT(pipe))                                     
4000f400:	d0 07 60 30 	ld  [ %i5 + 0x30 ], %o0                        
4000f404:	40 00 05 52 	call  4001094c <rtems_barrier_wait>            
4000f408:	92 10 20 00 	clr  %o1                                       
4000f40c:	80 a0 00 08 	cmp  %g0, %o0                                  
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
4000f410:	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))                                     
4000f414:	b8 60 20 00 	subx  %g0, 0, %i4                              
        ret = -EINTR;                                                 
      if (! PIPE_LOCK(pipe)) {                                        
4000f418:	92 10 20 00 	clr  %o1                                       
4000f41c:	94 10 20 00 	clr  %o2                                       
4000f420:	7f ff ea 19 	call  40009c84 <rtems_semaphore_obtain>        
4000f424:	b8 0f 3f fc 	and  %i4, -4, %i4                              
4000f428:	80 a2 20 00 	cmp  %o0, 0                                    
4000f42c:	12 80 00 45 	bne  4000f540 <pipe_write+0x1d8>               <== NEVER TAKEN
4000f430:	80 a7 20 00 	cmp  %i4, 0                                    
        /* WARN waitingWriters not restored! */                       
        ret = -EINTR;                                                 
        goto out_nolock;                                              
      }                                                               
      pipe->waitingWriters --;                                        
4000f434:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
4000f438:	82 00 7f ff 	add  %g1, -1, %g1                              
      if (ret != 0)                                                   
4000f43c:	12 80 00 3d 	bne  4000f530 <pipe_write+0x1c8>               <== NEVER TAKEN
4000f440:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
        goto out_locked;                                              
                                                                      
      if (pipe->Readers == 0) {                                       
4000f444:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000f448:	80 a0 60 00 	cmp  %g1, 0                                    
4000f44c:	22 80 00 2b 	be,a   4000f4f8 <pipe_write+0x190>             <== NEVER TAKEN
4000f450:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        <== NOT EXECUTED
4000f454:	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) {                                
4000f458:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4000f45c:	84 27 00 01 	sub  %i4, %g1, %g2                             
4000f460:	80 a0 80 10 	cmp  %g2, %l0                                  
4000f464:	2a bf ff df 	bcs,a   4000f3e0 <pipe_write+0x78>             <== NEVER TAKEN
4000f468:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        <== NOT EXECUTED
        ret = -EPIPE;                                                 
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
4000f46c:	86 26 80 11 	sub  %i2, %l1, %g3                             
4000f470:	80 a0 80 03 	cmp  %g2, %g3                                  
4000f474:	08 80 00 03 	bleu  4000f480 <pipe_write+0x118>              
4000f478:	a0 10 00 02 	mov  %g2, %l0                                  
4000f47c:	a0 10 00 03 	mov  %g3, %l0                                  
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
4000f480:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
4000f484:	92 10 00 1c 	mov  %i4, %o1                                  
4000f488:	40 00 3f e6 	call  4001f420 <.urem>                         
4000f48c:	90 00 40 08 	add  %g1, %o0, %o0                             
    if (chunk > chunk1) {                                             
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000f490:	c2 07 40 00 	ld  [ %i5 ], %g1                               
        goto out_locked;                                              
      }                                                               
    }                                                                 
                                                                      
    chunk = MIN(count - written, PIPE_SPACE(pipe));                   
    chunk1 = pipe->Size - PIPE_WSTART(pipe);                          
4000f494:	b8 27 00 08 	sub  %i4, %o0, %i4                             
    if (chunk > chunk1) {                                             
4000f498:	80 a4 00 1c 	cmp  %l0, %i4                                  
4000f49c:	04 80 00 2d 	ble  4000f550 <pipe_write+0x1e8>               
4000f4a0:	92 06 40 11 	add  %i1, %l1, %o1                             
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000f4a4:	94 10 00 1c 	mov  %i4, %o2                                  
4000f4a8:	40 00 10 d7 	call  40013804 <memcpy>                        
4000f4ac:	90 00 40 08 	add  %g1, %o0, %o0                             
      memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4000f4b0:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000f4b4:	92 07 00 11 	add  %i4, %l1, %o1                             
4000f4b8:	94 24 00 1c 	sub  %l0, %i4, %o2                             
4000f4bc:	40 00 10 d2 	call  40013804 <memcpy>                        
4000f4c0:	92 06 40 09 	add  %i1, %o1, %o1                             
    }                                                                 
    else                                                              
      memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
                                                                      
    pipe->Length += chunk;                                            
4000f4c4:	c4 07 60 0c 	ld  [ %i5 + 0xc ], %g2                         
    if (pipe->waitingReaders > 0)                                     
4000f4c8:	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;                                            
4000f4cc:	84 00 80 10 	add  %g2, %l0, %g2                             
    if (pipe->waitingReaders > 0)                                     
4000f4d0:	80 a0 60 00 	cmp  %g1, 0                                    
4000f4d4:	12 80 00 24 	bne  4000f564 <pipe_write+0x1fc>               
4000f4d8:	c4 27 60 0c 	st  %g2, [ %i5 + 0xc ]                         
      PIPE_WAKEUPREADERS(pipe);                                       
    written += chunk;                                                 
4000f4dc:	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) {                                           
4000f4e0:	80 a6 80 18 	cmp  %i2, %i0                                  
4000f4e4:	08 80 00 12 	bleu  4000f52c <pipe_write+0x1c4>              <== ALWAYS TAKEN
4000f4e8:	a2 10 00 18 	mov  %i0, %l1                                  
4000f4ec:	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;                                                        
4000f4f0:	10 bf ff b6 	b  4000f3c8 <pipe_write+0x60>                  <== NOT EXECUTED
4000f4f4:	a0 10 20 01 	mov  1, %l0                                    <== NOT EXECUTED
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
4000f4f8:	7f ff ea 32 	call  40009dc0 <rtems_semaphore_release>       
4000f4fc:	b8 10 3f e0 	mov  -32, %i4                                  
                                                                      
out_nolock:                                                           
#ifdef RTEMS_POSIX_API                                                
  /* Signal SIGPIPE */                                                
  if (ret == -EPIPE)                                                  
    kill(getpid(), SIGPIPE);                                          
4000f500:	40 00 01 49 	call  4000fa24 <getpid>                        
4000f504:	01 00 00 00 	nop                                            
4000f508:	40 00 02 c8 	call  40010028 <kill>                          
4000f50c:	92 10 20 0d 	mov  0xd, %o1	! d <PROM_START+0xd>             
#endif                                                                
                                                                      
  if (written > 0)                                                    
4000f510:	80 a6 20 00 	cmp  %i0, 0                                    
4000f514:	14 bf ff 9a 	bg  4000f37c <pipe_write+0x14>                 
4000f518:	01 00 00 00 	nop                                            
4000f51c:	81 c7 e0 08 	ret                                            
4000f520:	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;                            
4000f524:	10 bf ff a7 	b  4000f3c0 <pipe_write+0x58>                  
4000f528:	a0 10 00 1a 	mov  %i2, %l0                                  
                                                                      
  while (written < count) {                                           
4000f52c:	b8 10 20 00 	clr  %i4                                       
    /* Write of more than PIPE_BUF bytes can be interleaved */        
    chunk = 1;                                                        
  }                                                                   
                                                                      
out_locked:                                                           
  PIPE_UNLOCK(pipe);                                                  
4000f530:	7f ff ea 24 	call  40009dc0 <rtems_semaphore_release>       
4000f534:	d0 07 60 28 	ld  [ %i5 + 0x28 ], %o0                        
  /* Signal SIGPIPE */                                                
  if (ret == -EPIPE)                                                  
    kill(getpid(), SIGPIPE);                                          
#endif                                                                
                                                                      
  if (written > 0)                                                    
4000f538:	10 bf ff f7 	b  4000f514 <pipe_write+0x1ac>                 
4000f53c:	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;                                                 
4000f540:	10 bf ff f4 	b  4000f510 <pipe_write+0x1a8>                 <== NOT EXECUTED
4000f544:	b8 10 3f fc 	mov  -4, %i4                                   <== NOT EXECUTED
  /* Write nothing */                                                 
  if (count == 0)                                                     
    return 0;                                                         
                                                                      
  if (! PIPE_LOCK(pipe))                                              
    return -EINTR;                                                    
4000f548:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f54c:	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);
4000f550:	90 00 40 08 	add  %g1, %o0, %o0                             
4000f554:	40 00 10 ac 	call  40013804 <memcpy>                        
4000f558:	94 10 00 10 	mov  %l0, %o2                                  
                                                                      
    pipe->Length += chunk;                                            
4000f55c:	10 bf ff db 	b  4000f4c8 <pipe_write+0x160>                 
4000f560:	c4 07 60 0c 	ld  [ %i5 + 0xc ], %g2                         
    if (pipe->waitingReaders > 0)                                     
      PIPE_WAKEUPREADERS(pipe);                                       
4000f564:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        
4000f568:	40 00 04 e1 	call  400108ec <rtems_barrier_release>         
4000f56c:	92 07 bf fc 	add  %fp, -4, %o1                              
    written += chunk;                                                 
4000f570:	10 bf ff dc 	b  4000f4e0 <pipe_write+0x178>                 
4000f574:	b0 06 00 10 	add  %i0, %l0, %i0                             
                                                                      

400095cc <posix_memalign>: ) { /* * Update call statistics */ MSBUMP(memalign_calls, 1);
400095cc:	05 10 00 9d 	sethi  %hi(0x40027400), %g2                    
400095d0:	84 10 a0 68 	or  %g2, 0x68, %g2	! 40027468 <rtems_malloc_statistics>
400095d4:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
400095d8:	86 00 e0 01 	inc  %g3                                       
400095dc:	c6 20 a0 08 	st  %g3, [ %g2 + 8 ]                           
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
400095e0:	84 02 7f ff 	add  %o1, -1, %g2                              
400095e4:	80 88 80 09 	btst  %g2, %o1                                 
400095e8:	02 80 00 04 	be  400095f8 <posix_memalign+0x2c>             <== ALWAYS TAKEN
400095ec:	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 );                  
}                                                                     
400095f0:	81 c3 e0 08 	retl                                           
400095f4:	90 10 20 16 	mov  0x16, %o0                                 
  /*                                                                  
   *  Update call statistics                                          
   */                                                                 
  MSBUMP(memalign_calls, 1);                                          
                                                                      
  if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
400095f8:	08 bf ff fe 	bleu  400095f0 <posix_memalign+0x24>           
400095fc:	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 );                  
40009600:	82 13 c0 00 	mov  %o7, %g1                                  
40009604:	40 00 00 89 	call  40009828 <rtems_memalign>                
40009608:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

4000d040 <pthread_attr_setschedpolicy>: int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) {
4000d040:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || !attr->is_initialized )                               
4000d044:	80 a0 60 00 	cmp  %g1, 0                                    
4000d048:	02 80 00 06 	be  4000d060 <pthread_attr_setschedpolicy+0x20>
4000d04c:	90 10 20 16 	mov  0x16, %o0                                 
4000d050:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000d054:	80 a0 a0 00 	cmp  %g2, 0                                    
4000d058:	12 80 00 04 	bne  4000d068 <pthread_attr_setschedpolicy+0x28>
4000d05c:	80 a2 60 04 	cmp  %o1, 4                                    
      return 0;                                                       
                                                                      
    default:                                                          
      return ENOTSUP;                                                 
  }                                                                   
}                                                                     
4000d060:	81 c3 e0 08 	retl                                           
4000d064:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  if ( !attr || !attr->is_initialized )                               
    return EINVAL;                                                    
                                                                      
  switch ( policy ) {                                                 
4000d068:	18 80 00 09 	bgu  4000d08c <pthread_attr_setschedpolicy+0x4c>
4000d06c:	84 10 20 01 	mov  1, %g2	! 1 <PROM_START+0x1>               
4000d070:	85 28 80 09 	sll  %g2, %o1, %g2                             
4000d074:	80 88 a0 17 	btst  0x17, %g2                                
4000d078:	02 80 00 05 	be  4000d08c <pthread_attr_setschedpolicy+0x4c><== NEVER TAKEN
4000d07c:	01 00 00 00 	nop                                            
    case SCHED_OTHER:                                                 
    case SCHED_FIFO:                                                  
    case SCHED_RR:                                                    
    case SCHED_SPORADIC:                                              
      attr->schedpolicy = policy;                                     
4000d080:	d2 20 60 14 	st  %o1, [ %g1 + 0x14 ]                        
      return 0;                                                       
4000d084:	81 c3 e0 08 	retl                                           
4000d088:	90 10 20 00 	clr  %o0                                       
                                                                      
    default:                                                          
      return ENOTSUP;                                                 
  }                                                                   
}                                                                     
4000d08c:	81 c3 e0 08 	retl                                           
4000d090:	90 10 20 86 	mov  0x86, %o0                                 
                                                                      

400084d4 <pthread_barrier_init>: int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) {
400084d4:	9d e3 bf 90 	save  %sp, -112, %sp                           
  const pthread_barrierattr_t   *the_attr;                            
                                                                      
  /*                                                                  
   *  Error check parameters                                          
   */                                                                 
  if ( !barrier )                                                     
400084d8:	80 a6 20 00 	cmp  %i0, 0                                    
400084dc:	02 80 00 04 	be  400084ec <pthread_barrier_init+0x18>       
400084e0:	80 a6 a0 00 	cmp  %i2, 0                                    
    return EINVAL;                                                    
                                                                      
  if ( count == 0 )                                                   
400084e4:	12 80 00 04 	bne  400084f4 <pthread_barrier_init+0x20>      
400084e8:	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;                                                           
}                                                                     
400084ec:	81 c7 e0 08 	ret                                            
400084f0:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
400084f4:	02 80 00 23 	be  40008580 <pthread_barrier_init+0xac>       
400084f8:	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 )                                    
400084fc:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40008500:	80 a0 60 00 	cmp  %g1, 0                                    
40008504:	02 bf ff fa 	be  400084ec <pthread_barrier_init+0x18>       
40008508:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  switch ( the_attr->process_shared ) {                               
4000850c:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
40008510:	80 a0 60 00 	cmp  %g1, 0                                    
40008514:	12 bf ff f6 	bne  400084ec <pthread_barrier_init+0x18>      <== NEVER TAKEN
40008518:	03 10 00 65 	sethi  %hi(0x40019400), %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;                  
4000851c:	c4 00 60 e0 	ld  [ %g1 + 0xe0 ], %g2	! 400194e0 <_Thread_Dispatch_disable_level>
  }                                                                   
                                                                      
  /*                                                                  
   * Convert from POSIX attributes to Core Barrier attributes         
   */                                                                 
  the_attributes.discipline    = CORE_BARRIER_AUTOMATIC_RELEASE;      
40008520:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
                                                                      
    ++level;                                                          
40008524:	84 00 a0 01 	inc  %g2                                       
  the_attributes.maximum_count = count;                               
40008528:	f4 27 bf f4 	st  %i2, [ %fp + -12 ]                         
    _Thread_Dispatch_disable_level = level;                           
4000852c:	c4 20 60 e0 	st  %g2, [ %g1 + 0xe0 ]                        
 *  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 *)                                    
40008530:	39 10 00 66 	sethi  %hi(0x40019800), %i4                    
40008534:	40 00 08 ee 	call  4000a8ec <_Objects_Allocate>             
40008538:	90 17 20 64 	or  %i4, 0x64, %o0	! 40019864 <_POSIX_Barrier_Information>
   */                                                                 
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _POSIX_Barrier_Allocate();                            
                                                                      
  if ( !the_barrier ) {                                               
4000853c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40008540:	02 80 00 14 	be  40008590 <pthread_barrier_init+0xbc>       
40008544:	90 07 60 10 	add  %i5, 0x10, %o0                            
    _Thread_Enable_dispatch();                                        
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 
40008548:	40 00 06 37 	call  40009e24 <_CORE_barrier_Initialize>      
4000854c:	92 07 bf f0 	add  %fp, -16, %o1                             
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40008550:	c4 17 60 0a 	lduh  [ %i5 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40008554:	b8 17 20 64 	or  %i4, 0x64, %i4                             
40008558:	c6 07 20 1c 	ld  [ %i4 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
4000855c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40008560:	85 28 a0 02 	sll  %g2, 2, %g2                               
40008564:	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;                                   
40008568:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
  );                                                                  
                                                                      
  /*                                                                  
   * Exit the critical section and return the user an operational barrier
   */                                                                 
  *barrier = the_barrier->Object.id;                                  
4000856c:	c2 26 00 00 	st  %g1, [ %i0 ]                               
  _Thread_Enable_dispatch();                                          
40008570:	40 00 0d f4 	call  4000bd40 <_Thread_Enable_dispatch>       
40008574:	b0 10 20 00 	clr  %i0                                       
40008578:	81 c7 e0 08 	ret                                            
4000857c:	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 );                      
40008580:	7f ff ff 9c 	call  400083f0 <pthread_barrierattr_init>      
40008584:	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 )                                    
40008588:	10 bf ff de 	b  40008500 <pthread_barrier_init+0x2c>        
4000858c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_barrier = _POSIX_Barrier_Allocate();                            
                                                                      
  if ( !the_barrier ) {                                               
    _Thread_Enable_dispatch();                                        
40008590:	40 00 0d ec 	call  4000bd40 <_Thread_Enable_dispatch>       
40008594:	b0 10 20 0b 	mov  0xb, %i0                                  
40008598:	81 c7 e0 08 	ret                                            
4000859c:	81 e8 00 00 	restore                                        
                                                                      

40007d68 <pthread_cleanup_push>: void pthread_cleanup_push( void (*routine)( void * ), void *arg ) {
40007d68:	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 )                                                     
40007d6c:	80 a6 20 00 	cmp  %i0, 0                                    
40007d70:	02 80 00 13 	be  40007dbc <pthread_cleanup_push+0x54>       
40007d74:	03 10 00 66 	sethi  %hi(0x40019800), %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;                  
40007d78:	c4 00 62 00 	ld  [ %g1 + 0x200 ], %g2	! 40019a00 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
40007d7c:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40007d80:	c4 20 62 00 	st  %g2, [ %g1 + 0x200 ]                       
    return;                                                           
                                                                      
  _Thread_Disable_dispatch();                                         
  handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
40007d84:	40 00 12 bc 	call  4000c874 <_Workspace_Allocate>           
40007d88:	90 10 20 10 	mov  0x10, %o0                                 
                                                                      
  if ( handler ) {                                                    
40007d8c:	80 a2 20 00 	cmp  %o0, 0                                    
40007d90:	02 80 00 09 	be  40007db4 <pthread_cleanup_push+0x4c>       <== NEVER TAKEN
40007d94:	03 10 00 67 	sethi  %hi(0x40019c00), %g1                    
    thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
40007d98:	c2 00 63 20 	ld  [ %g1 + 0x320 ], %g1	! 40019f20 <_Per_CPU_Information+0x10>
    handler_stack = &thread_support->Cancellation_Handlers;           
                                                                      
    handler->routine = routine;                                       
    handler->arg = arg;                                               
                                                                      
    _Chain_Append( handler_stack, &handler->Node );                   
40007d9c:	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;           
40007da0:	c2 00 61 50 	ld  [ %g1 + 0x150 ], %g1                       
                                                                      
    handler->routine = routine;                                       
40007da4:	f0 22 20 08 	st  %i0, [ %o0 + 8 ]                           
    handler->arg = arg;                                               
40007da8:	f2 22 20 0c 	st  %i1, [ %o0 + 0xc ]                         
                                                                      
    _Chain_Append( handler_stack, &handler->Node );                   
40007dac:	40 00 06 67 	call  40009748 <_Chain_Append>                 
40007db0:	90 00 60 e4 	add  %g1, 0xe4, %o0                            
  }                                                                   
  _Thread_Enable_dispatch();                                          
40007db4:	40 00 0e 33 	call  4000b680 <_Thread_Enable_dispatch>       
40007db8:	81 e8 00 00 	restore                                        
40007dbc:	81 c7 e0 08 	ret                                            
40007dc0:	81 e8 00 00 	restore                                        
                                                                      

40008d08 <pthread_cond_init>: */ int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) {
40008d08:	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;                                        
40008d0c:	80 a6 60 00 	cmp  %i1, 0                                    
40008d10:	22 80 00 27 	be,a   40008dac <pthread_cond_init+0xa4>       
40008d14:	33 10 00 63 	sethi  %hi(0x40018c00), %i1                    
  else        the_attr = &_POSIX_Condition_variables_Default_attributes;
                                                                      
  /*                                                                  
   *  Be careful about attributes when global!!!                      
   */                                                                 
  if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )           
40008d18:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2	! 40018c04 <IMFS_node_control_default+0x64>
40008d1c:	80 a0 a0 01 	cmp  %g2, 1                                    
40008d20:	02 80 00 06 	be  40008d38 <pthread_cond_init+0x30>          <== NEVER TAKEN
40008d24:	82 10 20 16 	mov  0x16, %g1                                 
    return EINVAL;                                                    
                                                                      
  if ( !the_attr->is_initialized )                                    
40008d28:	c4 06 40 00 	ld  [ %i1 ], %g2                               
40008d2c:	80 a0 a0 00 	cmp  %g2, 0                                    
40008d30:	32 80 00 04 	bne,a   40008d40 <pthread_cond_init+0x38>      
40008d34:	03 10 00 69 	sethi  %hi(0x4001a400), %g1                    
  *cond = the_cond->Object.id;                                        
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return 0;                                                           
}                                                                     
40008d38:	81 c7 e0 08 	ret                                            
40008d3c:	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;                  
40008d40:	c4 00 63 20 	ld  [ %g1 + 0x320 ], %g2                       
                                                                      
    ++level;                                                          
40008d44:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40008d48:	c4 20 63 20 	st  %g2, [ %g1 + 0x320 ]                       
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control                
  *_POSIX_Condition_variables_Allocate( void )                        
{                                                                     
  return (POSIX_Condition_variables_Control *)                        
40008d4c:	39 10 00 6a 	sethi  %hi(0x4001a800), %i4                    
40008d50:	40 00 0a 9e 	call  4000b7c8 <_Objects_Allocate>             
40008d54:	90 17 23 3c 	or  %i4, 0x33c, %o0	! 4001ab3c <_POSIX_Condition_variables_Information>
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  the_cond = _POSIX_Condition_variables_Allocate();                   
                                                                      
  if ( !the_cond ) {                                                  
40008d58:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40008d5c:	02 80 00 16 	be  40008db4 <pthread_cond_init+0xac>          
40008d60:	90 07 60 18 	add  %i5, 0x18, %o0                            
    _Thread_Enable_dispatch();                                        
    return ENOMEM;                                                    
  }                                                                   
                                                                      
  the_cond->process_shared  = the_attr->process_shared;               
40008d64:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
                                                                      
  the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;               
                                                                      
  _Thread_queue_Initialize(                                           
40008d68:	92 10 20 00 	clr  %o1                                       
40008d6c:	15 04 00 02 	sethi  %hi(0x10000800), %o2                    
40008d70:	96 10 20 74 	mov  0x74, %o3                                 
  if ( !the_cond ) {                                                  
    _Thread_Enable_dispatch();                                        
    return ENOMEM;                                                    
  }                                                                   
                                                                      
  the_cond->process_shared  = the_attr->process_shared;               
40008d74:	c2 27 60 10 	st  %g1, [ %i5 + 0x10 ]                        
                                                                      
  the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;               
                                                                      
  _Thread_queue_Initialize(                                           
40008d78:	40 00 11 c8 	call  4000d498 <_Thread_queue_Initialize>      
40008d7c:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40008d80:	c4 17 60 0a 	lduh  [ %i5 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40008d84:	b8 17 23 3c 	or  %i4, 0x33c, %i4                            
40008d88:	c6 07 20 1c 	ld  [ %i4 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40008d8c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40008d90:	85 28 a0 02 	sll  %g2, 2, %g2                               
40008d94:	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;                                   
40008d98:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    0                                                                 
  );                                                                  
                                                                      
  *cond = the_cond->Object.id;                                        
                                                                      
  _Thread_Enable_dispatch();                                          
40008d9c:	40 00 0f a0 	call  4000cc1c <_Thread_Enable_dispatch>       
40008da0:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  return 0;                                                           
40008da4:	10 bf ff e5 	b  40008d38 <pthread_cond_init+0x30>           
40008da8:	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;
40008dac:	10 bf ff db 	b  40008d18 <pthread_cond_init+0x10>           
40008db0:	b2 16 62 dc 	or  %i1, 0x2dc, %i1                            
  _Thread_Disable_dispatch();                                         
                                                                      
  the_cond = _POSIX_Condition_variables_Allocate();                   
                                                                      
  if ( !the_cond ) {                                                  
    _Thread_Enable_dispatch();                                        
40008db4:	40 00 0f 9a 	call  4000cc1c <_Thread_Enable_dispatch>       
40008db8:	01 00 00 00 	nop                                            
    return ENOMEM;                                                    
40008dbc:	10 bf ff df 	b  40008d38 <pthread_cond_init+0x30>           
40008dc0:	82 10 20 0c 	mov  0xc, %g1	! c <PROM_START+0xc>             
                                                                      

40008b6c <pthread_condattr_destroy>: */ int pthread_condattr_destroy( pthread_condattr_t *attr ) {
40008b6c:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || attr->is_initialized == false )                       
40008b70:	80 a0 60 00 	cmp  %g1, 0                                    
40008b74:	02 80 00 06 	be  40008b8c <pthread_condattr_destroy+0x20>   
40008b78:	90 10 20 16 	mov  0x16, %o0                                 
40008b7c:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40008b80:	80 a0 a0 00 	cmp  %g2, 0                                    
40008b84:	32 80 00 04 	bne,a   40008b94 <pthread_condattr_destroy+0x28><== ALWAYS TAKEN
40008b88:	c0 20 40 00 	clr  [ %g1 ]                                   
    return EINVAL;                                                    
                                                                      
  attr->is_initialized = false;                                       
  return 0;                                                           
}                                                                     
40008b8c:	81 c3 e0 08 	retl                                           
40008b90:	01 00 00 00 	nop                                            
40008b94:	81 c3 e0 08 	retl                                           
40008b98:	90 10 20 00 	clr  %o0	! 0 <PROM_START>                      
                                                                      

40008214 <pthread_create>: pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) {
40008214:	9d e3 bf 58 	save  %sp, -168, %sp                           
  int                                 schedpolicy = SCHED_RR;         
  struct sched_param                  schedparam;                     
  Objects_Name                        name;                           
  int                                 rc;                             
                                                                      
  if ( !start_routine )                                               
40008218:	80 a6 a0 00 	cmp  %i2, 0                                    
4000821c:	02 80 00 0a 	be  40008244 <pthread_create+0x30>             
40008220:	ba 10 20 0e 	mov  0xe, %i5                                  
    return EFAULT;                                                    
                                                                      
  the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;      
40008224:	80 a6 60 00 	cmp  %i1, 0                                    
40008228:	22 80 00 63 	be,a   400083b4 <pthread_create+0x1a0>         
4000822c:	33 10 00 7c 	sethi  %hi(0x4001f000), %i1                    
                                                                      
  if ( !the_attr->is_initialized )                                    
40008230:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40008234:	80 a0 60 00 	cmp  %g1, 0                                    
40008238:	32 80 00 05 	bne,a   4000824c <pthread_create+0x38>         
4000823c:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
      schedpolicy = the_attr->schedpolicy;                            
      schedparam  = the_attr->schedparam;                             
      break;                                                          
                                                                      
    default:                                                          
      return EINVAL;                                                  
40008240:	ba 10 20 16 	mov  0x16, %i5                                 
   */                                                                 
  *thread = the_thread->Object.id;                                    
                                                                      
  _RTEMS_Unlock_allocator();                                          
  return 0;                                                           
}                                                                     
40008244:	81 c7 e0 08 	ret                                            
40008248:	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) )
4000824c:	80 a0 60 00 	cmp  %g1, 0                                    
40008250:	02 80 00 07 	be  4000826c <pthread_create+0x58>             
40008254:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
40008258:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
4000825c:	c2 00 60 00 	ld  [ %g1 ], %g1                               
40008260:	80 a0 80 01 	cmp  %g2, %g1                                  
40008264:	0a bf ff f8 	bcs  40008244 <pthread_create+0x30>            
40008268:	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 ) {                                 
4000826c:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
40008270:	80 a0 60 01 	cmp  %g1, 1                                    
40008274:	02 80 00 52 	be  400083bc <pthread_create+0x1a8>            
40008278:	80 a0 60 02 	cmp  %g1, 2                                    
4000827c:	32 bf ff f2 	bne,a   40008244 <pthread_create+0x30>         
40008280:	ba 10 20 16 	mov  0x16, %i5                                 
      schedparam  = api->schedparam;                                  
      break;                                                          
                                                                      
    case PTHREAD_EXPLICIT_SCHED:                                      
      schedpolicy = the_attr->schedpolicy;                            
      schedparam  = the_attr->schedparam;                             
40008284:	da 06 60 18 	ld  [ %i1 + 0x18 ], %o5                        
40008288:	de 06 60 1c 	ld  [ %i1 + 0x1c ], %o7                        
4000828c:	fa 06 60 20 	ld  [ %i1 + 0x20 ], %i5                        
40008290:	c8 06 60 24 	ld  [ %i1 + 0x24 ], %g4                        
40008294:	c6 06 60 28 	ld  [ %i1 + 0x28 ], %g3                        
40008298:	c4 06 60 2c 	ld  [ %i1 + 0x2c ], %g2                        
4000829c:	c2 06 60 30 	ld  [ %i1 + 0x30 ], %g1                        
      schedpolicy = api->schedpolicy;                                 
      schedparam  = api->schedparam;                                  
      break;                                                          
                                                                      
    case PTHREAD_EXPLICIT_SCHED:                                      
      schedpolicy = the_attr->schedpolicy;                            
400082a0:	f8 06 60 14 	ld  [ %i1 + 0x14 ], %i4                        
      schedparam  = the_attr->schedparam;                             
400082a4:	da 27 bf e4 	st  %o5, [ %fp + -28 ]                         
400082a8:	de 27 bf e8 	st  %o7, [ %fp + -24 ]                         
400082ac:	fa 27 bf ec 	st  %i5, [ %fp + -20 ]                         
400082b0:	c8 27 bf f0 	st  %g4, [ %fp + -16 ]                         
400082b4:	c6 27 bf f4 	st  %g3, [ %fp + -12 ]                         
400082b8:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
400082bc:	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 )           
400082c0:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400082c4:	80 a0 60 00 	cmp  %g1, 0                                    
400082c8:	12 bf ff df 	bne  40008244 <pthread_create+0x30>            
400082cc:	ba 10 20 86 	mov  0x86, %i5                                 
    return ENOTSUP;                                                   
                                                                      
  /*                                                                  
   *  Interpret the scheduling parameters.                            
   */                                                                 
  if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )       
400082d0:	40 00 1a 17 	call  4000eb2c <_POSIX_Priority_Is_valid>      
400082d4:	d0 07 bf e4 	ld  [ %fp + -28 ], %o0                         
400082d8:	80 8a 20 ff 	btst  0xff, %o0                                
400082dc:	02 bf ff da 	be  40008244 <pthread_create+0x30>             <== NEVER TAKEN
400082e0:	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);
400082e4:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
    return EINVAL;                                                    
                                                                      
  core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
400082e8:	e0 07 bf e4 	ld  [ %fp + -28 ], %l0                         
400082ec:	e8 08 63 fc 	ldub  [ %g1 + 0x3fc ], %l4                     
                                                                      
  /*                                                                  
   *  Set the core scheduling policy information.                     
   */                                                                 
  rc = _POSIX_Thread_Translate_sched_param(                           
400082f0:	90 10 00 1c 	mov  %i4, %o0                                  
400082f4:	92 07 bf e4 	add  %fp, -28, %o1                             
400082f8:	94 07 bf dc 	add  %fp, -36, %o2                             
400082fc:	40 00 1a 19 	call  4000eb60 <_POSIX_Thread_Translate_sched_param>
40008300:	96 07 bf e0 	add  %fp, -32, %o3                             
    schedpolicy,                                                      
    &schedparam,                                                      
    &budget_algorithm,                                                
    &budget_callout                                                   
  );                                                                  
  if ( rc )                                                           
40008304:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40008308:	12 bf ff cf 	bne  40008244 <pthread_create+0x30>            
4000830c:	25 10 00 83 	sethi  %hi(0x40020c00), %l2                    
  #endif                                                              
                                                                      
  /*                                                                  
   *  Lock the allocator mutex for protection                         
   */                                                                 
  _RTEMS_Lock_allocator();                                            
40008310:	d0 04 a2 20 	ld  [ %l2 + 0x220 ], %o0	! 40020e20 <_RTEMS_Allocator_Mutex>
40008314:	40 00 06 99 	call  40009d78 <_API_Mutex_Lock>               
40008318:	27 10 00 83 	sethi  %hi(0x40020c00), %l3                    
 *  _POSIX_Threads_Allocate                                           
 */                                                                   
                                                                      
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )  
{                                                                     
  return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
4000831c:	40 00 09 70 	call  4000a8dc <_Objects_Allocate>             
40008320:	90 14 e3 a4 	or  %l3, 0x3a4, %o0	! 40020fa4 <_POSIX_Threads_Information>
   *  Allocate the thread control block.                              
   *                                                                  
   *  NOTE:  Global threads are not currently supported.              
   */                                                                 
  the_thread = _POSIX_Threads_Allocate();                             
  if ( !the_thread ) {                                                
40008324:	a2 92 20 00 	orcc  %o0, 0, %l1                              
40008328:	02 80 00 1f 	be  400083a4 <pthread_create+0x190>            
4000832c:	05 10 00 80 	sethi  %hi(0x40020000), %g2                    
                                                                      
  /*                                                                  
   *  Initialize the core thread for this task.                       
   */                                                                 
  name.name_p = NULL;   /* posix threads don't have a name by default */
  status = _Thread_Initialize(                                        
40008330:	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 )                           
40008334:	d6 00 a0 00 	ld  [ %g2 ], %o3                               
                                                                      
  /*                                                                  
   *  Initialize the core thread for this task.                       
   */                                                                 
  name.name_p = NULL;   /* posix threads don't have a name by default */
  status = _Thread_Initialize(                                        
40008338:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
4000833c:	97 2a e0 01 	sll  %o3, 1, %o3                               
40008340:	80 a2 c0 01 	cmp  %o3, %g1                                  
40008344:	1a 80 00 03 	bcc  40008350 <pthread_create+0x13c>           
40008348:	d4 06 60 04 	ld  [ %i1 + 4 ], %o2                           
4000834c:	96 10 00 01 	mov  %g1, %o3                                  
40008350:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
40008354:	9a 0d 20 ff 	and  %l4, 0xff, %o5                            
40008358:	c2 23 a0 60 	st  %g1, [ %sp + 0x60 ]                        
4000835c:	82 10 20 01 	mov  1, %g1                                    
40008360:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
40008364:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
40008368:	c0 23 a0 68 	clr  [ %sp + 0x68 ]                            
4000836c:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
40008370:	82 07 bf d4 	add  %fp, -44, %g1                             
40008374:	90 14 e3 a4 	or  %l3, 0x3a4, %o0                            
40008378:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
4000837c:	92 10 00 11 	mov  %l1, %o1                                  
40008380:	98 10 20 00 	clr  %o4                                       
40008384:	40 00 0e a2 	call  4000be0c <_Thread_Initialize>            
40008388:	9a 23 40 10 	sub  %o5, %l0, %o5                             
    budget_callout,                                                   
    0,                    /* isr level */                             
    name                  /* posix threads don't have a name */       
  );                                                                  
                                                                      
  if ( !status ) {                                                    
4000838c:	80 8a 20 ff 	btst  0xff, %o0                                
40008390:	12 80 00 1e 	bne  40008408 <pthread_create+0x1f4>           
40008394:	11 10 00 83 	sethi  %hi(0x40020c00), %o0                    
                                                                      
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (                       
  Thread_Control *the_pthread                                         
)                                                                     
{                                                                     
  _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 
40008398:	92 10 00 11 	mov  %l1, %o1                                  
4000839c:	40 00 0a 48 	call  4000acbc <_Objects_Free>                 
400083a0:	90 12 23 a4 	or  %o0, 0x3a4, %o0                            
    _POSIX_Threads_Free( the_thread );                                
    _RTEMS_Unlock_allocator();                                        
400083a4:	d0 04 a2 20 	ld  [ %l2 + 0x220 ], %o0                       
400083a8:	40 00 06 89 	call  40009dcc <_API_Mutex_Unlock>             
400083ac:	ba 10 20 0b 	mov  0xb, %i5                                  
400083b0:	30 bf ff a5 	b,a   40008244 <pthread_create+0x30>           
  int                                 rc;                             
                                                                      
  if ( !start_routine )                                               
    return EFAULT;                                                    
                                                                      
  the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;      
400083b4:	10 bf ff 9f 	b  40008230 <pthread_create+0x1c>              
400083b8:	b2 16 63 dc 	or  %i1, 0x3dc, %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 ];    
400083bc:	03 10 00 84 	sethi  %hi(0x40021000), %g1                    
400083c0:	c2 00 62 c0 	ld  [ %g1 + 0x2c0 ], %g1	! 400212c0 <_Per_CPU_Information+0x10>
400083c4:	c2 00 61 50 	ld  [ %g1 + 0x150 ], %g1                       
      schedpolicy = api->schedpolicy;                                 
      schedparam  = api->schedparam;                                  
400083c8:	d8 00 60 88 	ld  [ %g1 + 0x88 ], %o4                        
400083cc:	da 00 60 8c 	ld  [ %g1 + 0x8c ], %o5                        
400083d0:	de 00 60 90 	ld  [ %g1 + 0x90 ], %o7                        
400083d4:	fa 00 60 94 	ld  [ %g1 + 0x94 ], %i5                        
400083d8:	c8 00 60 98 	ld  [ %g1 + 0x98 ], %g4                        
400083dc:	c6 00 60 9c 	ld  [ %g1 + 0x9c ], %g3                        
400083e0:	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;                                 
400083e4:	f8 00 60 84 	ld  [ %g1 + 0x84 ], %i4                        
      schedparam  = api->schedparam;                                  
400083e8:	d8 27 bf e4 	st  %o4, [ %fp + -28 ]                         
400083ec:	da 27 bf e8 	st  %o5, [ %fp + -24 ]                         
400083f0:	de 27 bf ec 	st  %o7, [ %fp + -20 ]                         
400083f4:	fa 27 bf f0 	st  %i5, [ %fp + -16 ]                         
400083f8:	c8 27 bf f4 	st  %g4, [ %fp + -12 ]                         
400083fc:	c6 27 bf f8 	st  %g3, [ %fp + -8 ]                          
      break;                                                          
40008400:	10 bf ff b0 	b  400082c0 <pthread_create+0xac>              
40008404:	c4 27 bf fc 	st  %g2, [ %fp + -4 ]                          
  }                                                                   
                                                                      
  /*                                                                  
   *  finish initializing the per API structure                       
   */                                                                 
  api = the_thread->API_Extensions[ THREAD_API_POSIX ];               
40008408:	e0 04 61 50 	ld  [ %l1 + 0x150 ], %l0                       
                                                                      
  api->Attributes  = *the_attr;                                       
4000840c:	92 10 00 19 	mov  %i1, %o1                                  
40008410:	94 10 20 40 	mov  0x40, %o2                                 
40008414:	40 00 25 ed 	call  40011bc8 <memcpy>                        
40008418:	90 10 00 10 	mov  %l0, %o0                                  
  api->detachstate = the_attr->detachstate;                           
4000841c:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
  api->schedpolicy = schedpolicy;                                     
  api->schedparam  = schedparam;                                      
40008420:	92 07 bf e4 	add  %fp, -28, %o1                             
40008424:	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;                           
40008428:	c2 24 20 40 	st  %g1, [ %l0 + 0x40 ]                        
  api->schedpolicy = schedpolicy;                                     
4000842c:	f8 24 20 84 	st  %i4, [ %l0 + 0x84 ]                        
  api->schedparam  = schedparam;                                      
40008430:	40 00 25 e6 	call  40011bc8 <memcpy>                        
40008434:	90 04 20 88 	add  %l0, 0x88, %o0                            
                                                                      
  /*                                                                  
   *  POSIX threads are allocated and started in one operation.       
   */                                                                 
  status = _Thread_Start(                                             
40008438:	90 10 00 11 	mov  %l1, %o0                                  
4000843c:	92 10 20 01 	mov  1, %o1                                    
40008440:	94 10 00 1a 	mov  %i2, %o2                                  
40008444:	96 10 00 1b 	mov  %i3, %o3                                  
40008448:	40 00 10 d3 	call  4000c794 <_Thread_Start>                 
4000844c:	98 10 20 00 	clr  %o4                                       
      _RTEMS_Unlock_allocator();                                      
      return EINVAL;                                                  
    }                                                                 
  #endif                                                              
                                                                      
  if ( schedpolicy == SCHED_SPORADIC ) {                              
40008450:	80 a7 20 04 	cmp  %i4, 4                                    
40008454:	02 80 00 07 	be  40008470 <pthread_create+0x25c>            
40008458:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  /*                                                                  
   *  Return the id and indicate we successfully created the thread   
   */                                                                 
  *thread = the_thread->Object.id;                                    
4000845c:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
                                                                      
  _RTEMS_Unlock_allocator();                                          
40008460:	d0 04 a2 20 	ld  [ %l2 + 0x220 ], %o0                       
40008464:	40 00 06 5a 	call  40009dcc <_API_Mutex_Unlock>             
40008468:	c2 26 00 00 	st  %g1, [ %i0 ]                               
4000846c:	30 bf ff 76 	b,a   40008244 <pthread_create+0x30>           
      return EINVAL;                                                  
    }                                                                 
  #endif                                                              
                                                                      
  if ( schedpolicy == SCHED_SPORADIC ) {                              
    _Watchdog_Insert_ticks(                                           
40008470:	40 00 10 f3 	call  4000c83c <_Timespec_To_ticks>            
40008474:	90 04 20 90 	add  %l0, 0x90, %o0                            
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40008478:	92 04 20 a8 	add  %l0, 0xa8, %o1                            
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
4000847c:	d0 24 20 b4 	st  %o0, [ %l0 + 0xb4 ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40008480:	11 10 00 83 	sethi  %hi(0x40020c00), %o0                    
40008484:	40 00 11 a8 	call  4000cb24 <_Watchdog_Insert>              
40008488:	90 12 22 38 	or  %o0, 0x238, %o0	! 40020e38 <_Watchdog_Ticks_chain>
  }                                                                   
                                                                      
  /*                                                                  
   *  Return the id and indicate we successfully created the thread   
   */                                                                 
  *thread = the_thread->Object.id;                                    
4000848c:	10 bf ff f5 	b  40008460 <pthread_create+0x24c>             
40008490:	c2 04 60 08 	ld  [ %l1 + 8 ], %g1                           
                                                                      

4001d05c <pthread_kill>: int pthread_kill( pthread_t thread, int sig ) {
4001d05c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  POSIX_API_Control  *api;                                            
  Thread_Control     *the_thread;                                     
  Objects_Locations  location;                                        
                                                                      
  if ( !sig )                                                         
4001d060:	80 a6 60 00 	cmp  %i1, 0                                    
4001d064:	02 80 00 31 	be  4001d128 <pthread_kill+0xcc>               
4001d068:	b8 06 7f ff 	add  %i1, -1, %i4                              
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
4001d06c:	80 a7 20 1f 	cmp  %i4, 0x1f                                 
4001d070:	18 80 00 2e 	bgu  4001d128 <pthread_kill+0xcc>              
4001d074:	90 10 00 18 	mov  %i0, %o0                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  the_thread = _Thread_Get( thread, &location );                      
4001d078:	7f ff b8 20 	call  4000b0f8 <_Thread_Get>                   
4001d07c:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4001d080:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001d084:	80 a0 60 00 	cmp  %g1, 0                                    
4001d088:	12 80 00 2e 	bne  4001d140 <pthread_kill+0xe4>              <== NEVER TAKEN
4001d08c:	ba 10 00 08 	mov  %o0, %i5                                  
4001d090:	11 10 00 7d 	sethi  %hi(0x4001f400), %o0                    
4001d094:	7f ff af b9 	call  40008f78 <_API_extensions_Add_post_switch>
4001d098:	90 12 22 ac 	or  %o0, 0x2ac, %o0	! 4001f6ac <_POSIX_signals_Post_switch>
                                                                      
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
                                                                      
      if ( sig ) {                                                    
                                                                      
        if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {  
4001d09c:	83 2e 60 02 	sll  %i1, 2, %g1                               
4001d0a0:	85 2e 60 04 	sll  %i1, 4, %g2                               
4001d0a4:	84 20 80 01 	sub  %g2, %g1, %g2                             
4001d0a8:	03 10 00 82 	sethi  %hi(0x40020800), %g1                    
4001d0ac:	82 10 60 20 	or  %g1, 0x20, %g1	! 40020820 <_POSIX_signals_Vectors>
4001d0b0:	82 00 40 02 	add  %g1, %g2, %g1                             
4001d0b4:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
4001d0b8:	80 a0 a0 01 	cmp  %g2, 1                                    
4001d0bc:	02 80 00 15 	be  4001d110 <pthread_kill+0xb4>               
4001d0c0:	c2 07 61 50 	ld  [ %i5 + 0x150 ], %g1                       
          return 0;                                                   
        }                                                             
                                                                      
        /* XXX critical section */                                    
                                                                      
        api->signals_pending |= signo_to_mask( sig );                 
4001d0c4:	c4 00 60 d4 	ld  [ %g1 + 0xd4 ], %g2                        
4001d0c8:	b6 10 20 01 	mov  1, %i3                                    
                                                                      
        (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001d0cc:	90 10 00 1d 	mov  %i5, %o0                                  
4001d0d0:	b9 2e c0 1c 	sll  %i3, %i4, %i4                             
4001d0d4:	92 10 00 19 	mov  %i1, %o1                                  
          return 0;                                                   
        }                                                             
                                                                      
        /* XXX critical section */                                    
                                                                      
        api->signals_pending |= signo_to_mask( sig );                 
4001d0d8:	b8 10 80 1c 	or  %g2, %i4, %i4                              
                                                                      
        (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
4001d0dc:	94 10 20 00 	clr  %o2                                       
4001d0e0:	7f ff ff 86 	call  4001cef8 <_POSIX_signals_Unblock_thread> 
4001d0e4:	f8 20 60 d4 	st  %i4, [ %g1 + 0xd4 ]                        
                                                                      
        if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
4001d0e8:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
4001d0ec:	82 10 63 c0 	or  %g1, 0x3c0, %g1	! 400207c0 <_Per_CPU_Information>
4001d0f0:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
4001d0f4:	80 a0 a0 00 	cmp  %g2, 0                                    
4001d0f8:	02 80 00 06 	be  4001d110 <pthread_kill+0xb4>               
4001d0fc:	01 00 00 00 	nop                                            
4001d100:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
4001d104:	80 a7 40 02 	cmp  %i5, %g2                                  
4001d108:	02 80 00 06 	be  4001d120 <pthread_kill+0xc4>               
4001d10c:	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();                                  
4001d110:	7f ff b7 ee 	call  4000b0c8 <_Thread_Enable_dispatch>       
4001d114:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>                      
4001d118:	81 c7 e0 08 	ret                                            
4001d11c:	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;                                 
4001d120:	f6 28 60 0c 	stb  %i3, [ %g1 + 0xc ]                        
4001d124:	30 bf ff fb 	b,a   4001d110 <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 );                   
4001d128:	7f ff ce 06 	call  40010940 <__errno>                       
4001d12c:	b0 10 3f ff 	mov  -1, %i0                                   
4001d130:	82 10 20 16 	mov  0x16, %g1                                 
4001d134:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001d138:	81 c7 e0 08 	ret                                            
4001d13c:	81 e8 00 00 	restore                                        
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( ESRCH );                      
4001d140:	7f ff ce 00 	call  40010940 <__errno>                       <== NOT EXECUTED
4001d144:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001d148:	82 10 20 03 	mov  3, %g1                                    <== NOT EXECUTED
4001d14c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
}                                                                     
4001d150:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d154:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000a254 <pthread_mutex_timedlock>: */ int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) {
4000a254:	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 );       
4000a258:	90 10 00 19 	mov  %i1, %o0                                  
4000a25c:	40 00 00 38 	call  4000a33c <_POSIX_Absolute_timeout_to_ticks>
4000a260:	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 );   
4000a264:	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 );       
4000a268:	ba 10 00 08 	mov  %o0, %i5                                  
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
4000a26c:	80 a7 60 03 	cmp  %i5, 3                                    
4000a270:	02 80 00 0c 	be  4000a2a0 <pthread_mutex_timedlock+0x4c>    
4000a274:	90 10 00 18 	mov  %i0, %o0                                  
    do_wait = false;                                                  
                                                                      
  lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );   
4000a278:	7f ff ff bd 	call  4000a16c <_POSIX_Mutex_Lock_support>     
4000a27c:	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) ) {                         
4000a280:	80 a2 20 10 	cmp  %o0, 0x10                                 
4000a284:	12 80 00 0a 	bne  4000a2ac <pthread_mutex_timedlock+0x58>   
4000a288:	b0 10 00 08 	mov  %o0, %i0                                  
    if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )                   
4000a28c:	80 a7 60 00 	cmp  %i5, 0                                    
4000a290:	12 80 00 09 	bne  4000a2b4 <pthread_mutex_timedlock+0x60>   <== ALWAYS TAKEN
4000a294:	ba 07 7f ff 	add  %i5, -1, %i5                              
      return EINVAL;                                                  
4000a298:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000a29c:	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 );   
4000a2a0:	7f ff ff b3 	call  4000a16c <_POSIX_Mutex_Lock_support>     
4000a2a4:	92 10 20 01 	mov  1, %o1                                    
4000a2a8:	b0 10 00 08 	mov  %o0, %i0                                  
         status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                    
      return ETIMEDOUT;                                               
  }                                                                   
                                                                      
  return lock_status;                                                 
}                                                                     
4000a2ac:	81 c7 e0 08 	ret                                            
4000a2b0:	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 ||               
4000a2b4:	80 a7 60 01 	cmp  %i5, 1                                    
4000a2b8:	18 bf ff fd 	bgu  4000a2ac <pthread_mutex_timedlock+0x58>   <== NEVER TAKEN
4000a2bc:	01 00 00 00 	nop                                            
         status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                    
      return ETIMEDOUT;                                               
4000a2c0:	81 c7 e0 08 	ret                                            
4000a2c4:	91 e8 20 74 	restore  %g0, 0x74, %o0                        
                                                                      

40007c34 <pthread_mutexattr_gettype>: #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_gettype( const pthread_mutexattr_t *attr, int *type ) {
40007c34:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr )                                                        
40007c38:	80 a0 60 00 	cmp  %g1, 0                                    
40007c3c:	02 80 00 06 	be  40007c54 <pthread_mutexattr_gettype+0x20>  
40007c40:	90 10 20 16 	mov  0x16, %o0                                 
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
40007c44:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40007c48:	80 a0 a0 00 	cmp  %g2, 0                                    
40007c4c:	12 80 00 04 	bne  40007c5c <pthread_mutexattr_gettype+0x28> 
40007c50:	80 a2 60 00 	cmp  %o1, 0                                    
  if ( !type )                                                        
    return EINVAL;                                                    
                                                                      
  *type = attr->type;                                                 
  return 0;                                                           
}                                                                     
40007c54:	81 c3 e0 08 	retl                                           
40007c58:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
    return EINVAL;                                                    
                                                                      
  if ( !type )                                                        
40007c5c:	02 bf ff fe 	be  40007c54 <pthread_mutexattr_gettype+0x20>  <== NEVER TAKEN
40007c60:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  *type = attr->type;                                                 
40007c64:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
  return 0;                                                           
40007c68:	90 10 20 00 	clr  %o0                                       
}                                                                     
40007c6c:	81 c3 e0 08 	retl                                           
40007c70:	c2 22 40 00 	st  %g1, [ %o1 ]                               
                                                                      

40009e20 <pthread_mutexattr_setpshared>: int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) {
40009e20:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || !attr->is_initialized )                               
40009e24:	80 a0 60 00 	cmp  %g1, 0                                    
40009e28:	02 80 00 06 	be  40009e40 <pthread_mutexattr_setpshared+0x20>
40009e2c:	90 10 20 16 	mov  0x16, %o0                                 
40009e30:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40009e34:	80 a0 a0 00 	cmp  %g2, 0                                    
40009e38:	12 80 00 04 	bne  40009e48 <pthread_mutexattr_setpshared+0x28>
40009e3c:	80 a2 60 01 	cmp  %o1, 1                                    
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40009e40:	81 c3 e0 08 	retl                                           
40009e44:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  if ( !attr || !attr->is_initialized )                               
    return EINVAL;                                                    
                                                                      
  switch ( pshared ) {                                                
40009e48:	18 bf ff fe 	bgu  40009e40 <pthread_mutexattr_setpshared+0x20><== NEVER TAKEN
40009e4c:	01 00 00 00 	nop                                            
    case PTHREAD_PROCESS_SHARED:                                      
    case PTHREAD_PROCESS_PRIVATE:                                     
      attr->process_shared = pshared;                                 
40009e50:	d2 20 60 04 	st  %o1, [ %g1 + 4 ]                           
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40009e54:	81 c3 e0 08 	retl                                           
40009e58:	90 10 20 00 	clr  %o0                                       
                                                                      

40007cc8 <pthread_mutexattr_settype>: #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) {
40007cc8:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr || !attr->is_initialized )                               
40007ccc:	80 a0 60 00 	cmp  %g1, 0                                    
40007cd0:	02 80 00 06 	be  40007ce8 <pthread_mutexattr_settype+0x20>  
40007cd4:	90 10 20 16 	mov  0x16, %o0                                 
40007cd8:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40007cdc:	80 a0 a0 00 	cmp  %g2, 0                                    
40007ce0:	12 80 00 04 	bne  40007cf0 <pthread_mutexattr_settype+0x28> <== ALWAYS TAKEN
40007ce4:	80 a2 60 03 	cmp  %o1, 3                                    
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40007ce8:	81 c3 e0 08 	retl                                           
40007cec:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  if ( !attr || !attr->is_initialized )                               
    return EINVAL;                                                    
                                                                      
  switch ( type ) {                                                   
40007cf0:	18 bf ff fe 	bgu  40007ce8 <pthread_mutexattr_settype+0x20> 
40007cf4:	01 00 00 00 	nop                                            
    case PTHREAD_MUTEX_NORMAL:                                        
    case PTHREAD_MUTEX_RECURSIVE:                                     
    case PTHREAD_MUTEX_ERRORCHECK:                                    
    case PTHREAD_MUTEX_DEFAULT:                                       
      attr->type = type;                                              
40007cf8:	d2 20 60 10 	st  %o1, [ %g1 + 0x10 ]                        
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40007cfc:	81 c3 e0 08 	retl                                           
40007d00:	90 10 20 00 	clr  %o0                                       
                                                                      

40008948 <pthread_once>: int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) {
40008948:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if ( !once_control || !init_routine )                               
4000894c:	80 a6 60 00 	cmp  %i1, 0                                    
40008950:	12 80 00 05 	bne  40008964 <pthread_once+0x1c>              
40008954:	80 a6 20 00 	cmp  %i0, 0                                    
    return EINVAL;                                                    
40008958:	82 10 20 16 	mov  0x16, %g1                                 
      (*init_routine)();                                              
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
  }                                                                   
  return 0;                                                           
}                                                                     
4000895c:	81 c7 e0 08 	ret                                            
40008960:	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 )                               
40008964:	22 bf ff fe 	be,a   4000895c <pthread_once+0x14>            
40008968:	82 10 20 16 	mov  0x16, %g1                                 
    return EINVAL;                                                    
                                                                      
  if ( !once_control->init_executed ) {                               
4000896c:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
40008970:	80 a0 a0 00 	cmp  %g2, 0                                    
40008974:	12 bf ff fa 	bne  4000895c <pthread_once+0x14>              
40008978:	82 10 20 00 	clr  %g1                                       
    rtems_mode saveMode;                                              
    rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 
4000897c:	90 10 21 00 	mov  0x100, %o0                                
40008980:	92 10 21 00 	mov  0x100, %o1                                
40008984:	40 00 03 21 	call  40009608 <rtems_task_mode>               
40008988:	94 07 bf fc 	add  %fp, -4, %o2                              
    if ( !once_control->init_executed ) {                             
4000898c:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
40008990:	80 a0 60 00 	cmp  %g1, 0                                    
40008994:	02 80 00 09 	be  400089b8 <pthread_once+0x70>               <== ALWAYS TAKEN
40008998:	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);         
4000899c:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          <== NOT EXECUTED
400089a0:	92 10 21 00 	mov  0x100, %o1                                
400089a4:	40 00 03 19 	call  40009608 <rtems_task_mode>               
400089a8:	94 07 bf fc 	add  %fp, -4, %o2                              
  }                                                                   
  return 0;                                                           
400089ac:	82 10 20 00 	clr  %g1                                       
}                                                                     
400089b0:	81 c7 e0 08 	ret                                            
400089b4:	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;                            
400089b8:	c2 26 00 00 	st  %g1, [ %i0 ]                               
      once_control->init_executed = true;                             
      (*init_routine)();                                              
400089bc:	9f c6 40 00 	call  %i1                                      
400089c0:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
400089c4:	10 bf ff f7 	b  400089a0 <pthread_once+0x58>                
400089c8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
                                                                      

40008b90 <pthread_rwlock_init>: int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) {
40008b90:	9d e3 bf 90 	save  %sp, -112, %sp                           
  const pthread_rwlockattr_t  *the_attr;                              
                                                                      
  /*                                                                  
   *  Error check parameters                                          
   */                                                                 
  if ( !rwlock )                                                      
40008b94:	80 a6 20 00 	cmp  %i0, 0                                    
40008b98:	02 80 00 08 	be  40008bb8 <pthread_rwlock_init+0x28>        
40008b9c:	80 a6 60 00 	cmp  %i1, 0                                    
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   * If the user passed in NULL, use the default attributes           
   */                                                                 
  if ( attr ) {                                                       
40008ba0:	02 80 00 23 	be  40008c2c <pthread_rwlock_init+0x9c>        
40008ba4:	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 )                                    
40008ba8:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40008bac:	80 a0 60 00 	cmp  %g1, 0                                    
40008bb0:	32 80 00 04 	bne,a   40008bc0 <pthread_rwlock_init+0x30>    <== ALWAYS TAKEN
40008bb4:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
                                                                      
  *rwlock = the_rwlock->Object.id;                                    
                                                                      
  _Thread_Enable_dispatch();                                          
  return 0;                                                           
}                                                                     
40008bb8:	81 c7 e0 08 	ret                                            
40008bbc:	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 ) {                               
40008bc0:	80 a0 60 00 	cmp  %g1, 0                                    
40008bc4:	12 bf ff fd 	bne  40008bb8 <pthread_rwlock_init+0x28>       <== NEVER TAKEN
40008bc8:	03 10 00 93 	sethi  %hi(0x40024c00), %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;                  
40008bcc:	c4 00 60 b0 	ld  [ %g1 + 0xb0 ], %g2	! 40024cb0 <_Thread_Dispatch_disable_level>
 */                                                                   
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(         
  CORE_RWLock_Attributes *the_attributes                              
)                                                                     
{                                                                     
  the_attributes->XXX = 0;                                            
40008bd0:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
                                                                      
    ++level;                                                          
40008bd4:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40008bd8:	c4 20 60 b0 	st  %g2, [ %g1 + 0xb0 ]                        
 *  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 *)                                     
40008bdc:	39 10 00 93 	sethi  %hi(0x40024c00), %i4                    
40008be0:	40 00 0b 14 	call  4000b830 <_Objects_Allocate>             
40008be4:	90 17 22 b4 	or  %i4, 0x2b4, %o0	! 40024eb4 <_POSIX_RWLock_Information>
   */                                                                 
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_rwlock = _POSIX_RWLock_Allocate();                              
                                                                      
  if ( !the_rwlock ) {                                                
40008be8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40008bec:	02 80 00 14 	be  40008c3c <pthread_rwlock_init+0xac>        
40008bf0:	90 07 60 10 	add  %i5, 0x10, %o0                            
    _Thread_Enable_dispatch();                                        
    return EAGAIN;                                                    
  }                                                                   
                                                                      
  _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );    
40008bf4:	40 00 09 5f 	call  4000b170 <_CORE_RWLock_Initialize>       
40008bf8:	92 07 bf f4 	add  %fp, -12, %o1                             
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40008bfc:	c4 17 60 0a 	lduh  [ %i5 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40008c00:	b8 17 22 b4 	or  %i4, 0x2b4, %i4                            
40008c04:	c6 07 20 1c 	ld  [ %i4 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40008c08:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40008c0c:	85 28 a0 02 	sll  %g2, 2, %g2                               
40008c10:	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;                                   
40008c14:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    &_POSIX_RWLock_Information,                                       
    &the_rwlock->Object,                                              
    0                                                                 
  );                                                                  
                                                                      
  *rwlock = the_rwlock->Object.id;                                    
40008c18:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  _Thread_Enable_dispatch();                                          
40008c1c:	40 00 10 51 	call  4000cd60 <_Thread_Enable_dispatch>       
40008c20:	b0 10 20 00 	clr  %i0                                       
40008c24:	81 c7 e0 08 	ret                                            
40008c28:	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 );                  
40008c2c:	40 00 01 b6 	call  40009304 <pthread_rwlockattr_init>       
40008c30:	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 )                                    
40008c34:	10 bf ff de 	b  40008bac <pthread_rwlock_init+0x1c>         
40008c38:	c2 06 40 00 	ld  [ %i1 ], %g1                               
  _Thread_Disable_dispatch();             /* prevents deletion */     
                                                                      
  the_rwlock = _POSIX_RWLock_Allocate();                              
                                                                      
  if ( !the_rwlock ) {                                                
    _Thread_Enable_dispatch();                                        
40008c3c:	40 00 10 49 	call  4000cd60 <_Thread_Enable_dispatch>       
40008c40:	b0 10 20 0b 	mov  0xb, %i0                                  
40008c44:	81 c7 e0 08 	ret                                            
40008c48:	81 e8 00 00 	restore                                        
                                                                      

400091a0 <pthread_rwlock_timedrdlock>: int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) {
400091a0:	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 )                                                      
400091a4:	80 a6 20 00 	cmp  %i0, 0                                    
400091a8:	02 80 00 25 	be  4000923c <pthread_rwlock_timedrdlock+0x9c> 
400091ac:	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 );       
400091b0:	40 00 1a b0 	call  4000fc70 <_POSIX_Absolute_timeout_to_ticks>
400091b4:	90 10 00 19 	mov  %i1, %o0                                  
400091b8:	d2 06 00 00 	ld  [ %i0 ], %o1                               
400091bc:	ba 10 00 08 	mov  %o0, %i5                                  
400091c0:	94 07 bf f8 	add  %fp, -8, %o2                              
400091c4:	11 10 00 6f 	sethi  %hi(0x4001bc00), %o0                    
400091c8:	40 00 0b b8 	call  4000c0a8 <_Objects_Get>                  
400091cc:	90 12 21 94 	or  %o0, 0x194, %o0	! 4001bd94 <_POSIX_RWLock_Information>
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
400091d0:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
400091d4:	80 a0 60 00 	cmp  %g1, 0                                    
400091d8:	32 80 00 1a 	bne,a   40009240 <pthread_rwlock_timedrdlock+0xa0>
400091dc:	b0 10 20 16 	mov  0x16, %i0                                 
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_reading(                                
400091e0:	d2 06 00 00 	ld  [ %i0 ], %o1                               
400091e4:	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 )                
400091e8:	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(                                
400091ec:	90 02 20 10 	add  %o0, 0x10, %o0                            
400091f0:	80 a0 00 01 	cmp  %g0, %g1                                  
400091f4:	98 10 20 00 	clr  %o4                                       
400091f8:	b8 60 3f ff 	subx  %g0, -1, %i4                             
400091fc:	40 00 07 f6 	call  4000b1d4 <_CORE_RWLock_Obtain_for_reading>
40009200:	94 10 00 1c 	mov  %i4, %o2                                  
	do_wait,                                                             
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
40009204:	40 00 0f 60 	call  4000cf84 <_Thread_Enable_dispatch>       
40009208:	01 00 00 00 	nop                                            
      if ( !do_wait ) {                                               
        if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
4000920c:	03 10 00 70 	sethi  %hi(0x4001c000), %g1                    
40009210:	c2 00 60 f0 	ld  [ %g1 + 0xf0 ], %g1	! 4001c0f0 <_Per_CPU_Information+0x10>
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if ( !do_wait ) {                                               
40009214:	80 a7 20 00 	cmp  %i4, 0                                    
40009218:	12 80 00 05 	bne  4000922c <pthread_rwlock_timedrdlock+0x8c>
4000921c:	d0 00 60 34 	ld  [ %g1 + 0x34 ], %o0                        
        if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
40009220:	80 a2 20 02 	cmp  %o0, 2                                    
40009224:	02 80 00 09 	be  40009248 <pthread_rwlock_timedrdlock+0xa8> 
40009228:	80 a7 60 00 	cmp  %i5, 0                                    
	       status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )                     
	    return ETIMEDOUT;                                                
        }                                                             
      }                                                               
                                                                      
      return _POSIX_RWLock_Translate_core_RWLock_return_code(         
4000922c:	40 00 00 3f 	call  40009328 <_POSIX_RWLock_Translate_core_RWLock_return_code>
40009230:	01 00 00 00 	nop                                            
40009234:	81 c7 e0 08 	ret                                            
40009238:	91 e8 00 08 	restore  %g0, %o0, %o0                         
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
4000923c:	b0 10 20 16 	mov  0x16, %i0                                 
}                                                                     
40009240:	81 c7 e0 08 	ret                                            
40009244:	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 )                    
40009248:	22 bf ff fe 	be,a   40009240 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
4000924c:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
	    return EINVAL;                                                   
	  if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||                
40009250:	ba 07 7f ff 	add  %i5, -1, %i5                              
40009254:	80 a7 60 01 	cmp  %i5, 1                                    
40009258:	18 bf ff f5 	bgu  4000922c <pthread_rwlock_timedrdlock+0x8c><== NEVER TAKEN
4000925c:	b0 10 20 74 	mov  0x74, %i0                                 
40009260:	30 bf ff f8 	b,a   40009240 <pthread_rwlock_timedrdlock+0xa0>
                                                                      

40009264 <pthread_rwlock_timedwrlock>: int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) {
40009264:	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 )                                                      
40009268:	80 a6 20 00 	cmp  %i0, 0                                    
4000926c:	02 80 00 25 	be  40009300 <pthread_rwlock_timedwrlock+0x9c> 
40009270:	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 );       
40009274:	40 00 1a 7f 	call  4000fc70 <_POSIX_Absolute_timeout_to_ticks>
40009278:	90 10 00 19 	mov  %i1, %o0                                  
4000927c:	d2 06 00 00 	ld  [ %i0 ], %o1                               
40009280:	ba 10 00 08 	mov  %o0, %i5                                  
40009284:	94 07 bf f8 	add  %fp, -8, %o2                              
40009288:	11 10 00 6f 	sethi  %hi(0x4001bc00), %o0                    
4000928c:	40 00 0b 87 	call  4000c0a8 <_Objects_Get>                  
40009290:	90 12 21 94 	or  %o0, 0x194, %o0	! 4001bd94 <_POSIX_RWLock_Information>
  if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )                
    do_wait = false;                                                  
                                                                      
  the_rwlock = _POSIX_RWLock_Get( rwlock, &location );                
  switch ( location ) {                                               
40009294:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40009298:	80 a0 60 00 	cmp  %g1, 0                                    
4000929c:	32 80 00 1a 	bne,a   40009304 <pthread_rwlock_timedwrlock+0xa0>
400092a0:	b0 10 20 16 	mov  0x16, %i0                                 
                                                                      
    case OBJECTS_LOCAL:                                               
                                                                      
      _CORE_RWLock_Obtain_for_writing(                                
400092a4:	d2 06 00 00 	ld  [ %i0 ], %o1                               
400092a8:	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 )                
400092ac:	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(                                
400092b0:	90 02 20 10 	add  %o0, 0x10, %o0                            
400092b4:	80 a0 00 01 	cmp  %g0, %g1                                  
400092b8:	98 10 20 00 	clr  %o4                                       
400092bc:	b8 60 3f ff 	subx  %g0, -1, %i4                             
400092c0:	40 00 07 fa 	call  4000b2a8 <_CORE_RWLock_Obtain_for_writing>
400092c4:	94 10 00 1c 	mov  %i4, %o2                                  
	do_wait,                                                             
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
400092c8:	40 00 0f 2f 	call  4000cf84 <_Thread_Enable_dispatch>       
400092cc:	01 00 00 00 	nop                                            
      if ( !do_wait &&                                                
           (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
400092d0:	03 10 00 70 	sethi  %hi(0x4001c000), %g1                    
400092d4:	c2 00 60 f0 	ld  [ %g1 + 0xf0 ], %g1	! 4001c0f0 <_Per_CPU_Information+0x10>
	ticks,                                                               
	NULL                                                                 
      );                                                              
                                                                      
      _Thread_Enable_dispatch();                                      
      if ( !do_wait &&                                                
400092d8:	80 a7 20 00 	cmp  %i4, 0                                    
400092dc:	12 80 00 05 	bne  400092f0 <pthread_rwlock_timedwrlock+0x8c>
400092e0:	d0 00 60 34 	ld  [ %g1 + 0x34 ], %o0                        
400092e4:	80 a2 20 02 	cmp  %o0, 2                                    
400092e8:	02 80 00 09 	be  4000930c <pthread_rwlock_timedwrlock+0xa8> 
400092ec:	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(         
400092f0:	40 00 00 0e 	call  40009328 <_POSIX_RWLock_Translate_core_RWLock_return_code>
400092f4:	01 00 00 00 	nop                                            
400092f8:	81 c7 e0 08 	ret                                            
400092fc:	91 e8 00 08 	restore  %g0, %o0, %o0                         
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return EINVAL;                                                      
40009300:	b0 10 20 16 	mov  0x16, %i0                                 
}                                                                     
40009304:	81 c7 e0 08 	ret                                            
40009308:	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 )                      
4000930c:	22 bf ff fe 	be,a   40009304 <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
40009310:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
	  return EINVAL;                                                     
	if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||                  
40009314:	ba 07 7f ff 	add  %i5, -1, %i5                              
40009318:	80 a7 60 01 	cmp  %i5, 1                                    
4000931c:	18 bf ff f5 	bgu  400092f0 <pthread_rwlock_timedwrlock+0x8c><== NEVER TAKEN
40009320:	b0 10 20 74 	mov  0x74, %i0                                 
40009324:	30 bf ff f8 	b,a   40009304 <pthread_rwlock_timedwrlock+0xa0>
                                                                      

40009b40 <pthread_rwlockattr_setpshared>: int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) {
40009b40:	82 10 00 08 	mov  %o0, %g1                                  
  if ( !attr )                                                        
40009b44:	80 a0 60 00 	cmp  %g1, 0                                    
40009b48:	02 80 00 06 	be  40009b60 <pthread_rwlockattr_setpshared+0x20>
40009b4c:	90 10 20 16 	mov  0x16, %o0                                 
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
40009b50:	c4 00 40 00 	ld  [ %g1 ], %g2                               
40009b54:	80 a0 a0 00 	cmp  %g2, 0                                    
40009b58:	12 80 00 04 	bne  40009b68 <pthread_rwlockattr_setpshared+0x28>
40009b5c:	80 a2 60 01 	cmp  %o1, 1                                    
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40009b60:	81 c3 e0 08 	retl                                           
40009b64:	01 00 00 00 	nop                                            
    return EINVAL;                                                    
                                                                      
  if ( !attr->is_initialized )                                        
    return EINVAL;                                                    
                                                                      
  switch ( pshared ) {                                                
40009b68:	18 bf ff fe 	bgu  40009b60 <pthread_rwlockattr_setpshared+0x20><== NEVER TAKEN
40009b6c:	01 00 00 00 	nop                                            
    case PTHREAD_PROCESS_SHARED:                                      
    case PTHREAD_PROCESS_PRIVATE:                                     
      attr->process_shared = pshared;                                 
40009b70:	d2 20 60 04 	st  %o1, [ %g1 + 4 ]                           
      return 0;                                                       
                                                                      
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
}                                                                     
40009b74:	81 c3 e0 08 	retl                                           
40009b78:	90 10 20 00 	clr  %o0                                       
                                                                      

4000ac00 <pthread_setschedparam>: int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) {
4000ac00:	9d e3 bf 90 	save  %sp, -112, %sp                           
  int                                  rc;                            
                                                                      
  /*                                                                  
   *  Check all the parameters                                        
   */                                                                 
  if ( !param )                                                       
4000ac04:	80 a6 a0 00 	cmp  %i2, 0                                    
4000ac08:	02 80 00 0a 	be  4000ac30 <pthread_setschedparam+0x30>      
4000ac0c:	ba 10 20 16 	mov  0x16, %i5                                 
    return EINVAL;                                                    
                                                                      
  rc = _POSIX_Thread_Translate_sched_param(                           
4000ac10:	90 10 00 19 	mov  %i1, %o0                                  
4000ac14:	92 10 00 1a 	mov  %i2, %o1                                  
4000ac18:	94 07 bf f4 	add  %fp, -12, %o2                             
4000ac1c:	40 00 18 82 	call  40010e24 <_POSIX_Thread_Translate_sched_param>
4000ac20:	96 07 bf f8 	add  %fp, -8, %o3                              
    policy,                                                           
    param,                                                            
    &budget_algorithm,                                                
    &budget_callout                                                   
  );                                                                  
  if ( rc )                                                           
4000ac24:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000ac28:	02 80 00 05 	be  4000ac3c <pthread_setschedparam+0x3c>      
4000ac2c:	90 10 00 18 	mov  %i0, %o0                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return ESRCH;                                                       
}                                                                     
4000ac30:	b0 10 00 1d 	mov  %i5, %i0                                  
4000ac34:	81 c7 e0 08 	ret                                            
4000ac38:	81 e8 00 00 	restore                                        
    return rc;                                                        
                                                                      
  /*                                                                  
   *  Actually change the scheduling policy and parameters            
   */                                                                 
  the_thread = _Thread_Get( thread, &location );                      
4000ac3c:	40 00 0c b3 	call  4000df08 <_Thread_Get>                   
4000ac40:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000ac44:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000ac48:	80 a0 60 00 	cmp  %g1, 0                                    
4000ac4c:	12 80 00 2b 	bne  4000acf8 <pthread_setschedparam+0xf8>     
4000ac50:	b6 10 00 08 	mov  %o0, %i3                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_POSIX ];           
4000ac54:	f8 02 21 50 	ld  [ %o0 + 0x150 ], %i4                       
                                                                      
      if ( api->schedpolicy == SCHED_SPORADIC )                       
4000ac58:	c2 07 20 84 	ld  [ %i4 + 0x84 ], %g1                        
4000ac5c:	80 a0 60 04 	cmp  %g1, 4                                    
4000ac60:	02 80 00 35 	be  4000ad34 <pthread_setschedparam+0x134>     
4000ac64:	01 00 00 00 	nop                                            
        (void) _Watchdog_Remove( &api->Sporadic_timer );              
                                                                      
      api->schedpolicy = policy;                                      
      api->schedparam  = *param;                                      
4000ac68:	c2 06 80 00 	ld  [ %i2 ], %g1                               
      the_thread->budget_algorithm = budget_algorithm;                
      the_thread->budget_callout   = budget_callout;                  
                                                                      
      switch ( api->schedpolicy ) {                                   
4000ac6c:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
      if ( api->schedpolicy == SCHED_SPORADIC )                       
        (void) _Watchdog_Remove( &api->Sporadic_timer );              
                                                                      
      api->schedpolicy = policy;                                      
      api->schedparam  = *param;                                      
4000ac70:	c2 27 20 88 	st  %g1, [ %i4 + 0x88 ]                        
4000ac74:	c4 06 a0 04 	ld  [ %i2 + 4 ], %g2                           
4000ac78:	c4 27 20 8c 	st  %g2, [ %i4 + 0x8c ]                        
4000ac7c:	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;                                      
4000ac80:	f2 27 20 84 	st  %i1, [ %i4 + 0x84 ]                        
      api->schedparam  = *param;                                      
4000ac84:	c4 27 20 90 	st  %g2, [ %i4 + 0x90 ]                        
4000ac88:	c4 06 a0 0c 	ld  [ %i2 + 0xc ], %g2                         
4000ac8c:	c4 27 20 94 	st  %g2, [ %i4 + 0x94 ]                        
4000ac90:	c4 06 a0 10 	ld  [ %i2 + 0x10 ], %g2                        
4000ac94:	c4 27 20 98 	st  %g2, [ %i4 + 0x98 ]                        
4000ac98:	c4 06 a0 14 	ld  [ %i2 + 0x14 ], %g2                        
4000ac9c:	c4 27 20 9c 	st  %g2, [ %i4 + 0x9c ]                        
4000aca0:	c4 06 a0 18 	ld  [ %i2 + 0x18 ], %g2                        
4000aca4:	c4 27 20 a0 	st  %g2, [ %i4 + 0xa0 ]                        
      the_thread->budget_algorithm = budget_algorithm;                
4000aca8:	c4 07 bf f4 	ld  [ %fp + -12 ], %g2                         
4000acac:	c4 26 e0 78 	st  %g2, [ %i3 + 0x78 ]                        
      the_thread->budget_callout   = budget_callout;                  
4000acb0:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
                                                                      
      switch ( api->schedpolicy ) {                                   
4000acb4:	06 80 00 0e 	bl  4000acec <pthread_setschedparam+0xec>      <== NEVER TAKEN
4000acb8:	c4 26 e0 7c 	st  %g2, [ %i3 + 0x7c ]                        
4000acbc:	80 a6 60 02 	cmp  %i1, 2                                    
4000acc0:	04 80 00 11 	ble  4000ad04 <pthread_setschedparam+0x104>    
4000acc4:	07 10 00 71 	sethi  %hi(0x4001c400), %g3                    
4000acc8:	80 a6 60 04 	cmp  %i1, 4                                    
4000accc:	12 80 00 08 	bne  4000acec <pthread_setschedparam+0xec>     <== NEVER TAKEN
4000acd0:	01 00 00 00 	nop                                            
             true                                                     
          );                                                          
          break;                                                      
                                                                      
        case SCHED_SPORADIC:                                          
          api->ss_high_priority = api->schedparam.sched_priority;     
4000acd4:	c2 27 20 a4 	st  %g1, [ %i4 + 0xa4 ]                        
          _Watchdog_Remove( &api->Sporadic_timer );                   
4000acd8:	40 00 10 b0 	call  4000ef98 <_Watchdog_Remove>              
4000acdc:	90 07 20 a8 	add  %i4, 0xa8, %o0                            
          _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );        
4000ace0:	90 10 20 00 	clr  %o0                                       
4000ace4:	7f ff ff 7b 	call  4000aad0 <_POSIX_Threads_Sporadic_budget_TSR>
4000ace8:	92 10 00 1b 	mov  %i3, %o1                                  
          break;                                                      
      }                                                               
                                                                      
      _Thread_Enable_dispatch();                                      
4000acec:	40 00 0c 7b 	call  4000ded8 <_Thread_Enable_dispatch>       
4000acf0:	b0 10 00 1d 	mov  %i5, %i0                                  
4000acf4:	30 bf ff d0 	b,a   4000ac34 <pthread_setschedparam+0x34>    
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return ESRCH;                                                       
4000acf8:	ba 10 20 03 	mov  3, %i5                                    
}                                                                     
4000acfc:	81 c7 e0 08 	ret                                            
4000ad00:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
4000ad04:	d2 08 e2 6c 	ldub  [ %g3 + 0x26c ], %o1                     
                                                                      
      switch ( api->schedpolicy ) {                                   
        case SCHED_OTHER:                                             
        case SCHED_FIFO:                                              
        case SCHED_RR:                                                
          the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;  
4000ad08:	05 10 00 74 	sethi  %hi(0x4001d000), %g2                    
4000ad0c:	c4 00 a3 d0 	ld  [ %g2 + 0x3d0 ], %g2	! 4001d3d0 <_Thread_Ticks_per_timeslice>
4000ad10:	92 22 40 01 	sub  %o1, %g1, %o1                             
                                                                      
          the_thread->real_priority =                                 
            _POSIX_Priority_To_core( api->schedparam.sched_priority );
                                                                      
          _Thread_Change_priority(                                    
4000ad14:	90 10 00 1b 	mov  %i3, %o0                                  
4000ad18:	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;  
4000ad1c:	c4 26 e0 74 	st  %g2, [ %i3 + 0x74 ]                        
                                                                      
          the_thread->real_priority =                                 
            _POSIX_Priority_To_core( api->schedparam.sched_priority );
                                                                      
          _Thread_Change_priority(                                    
4000ad20:	40 00 0b 34 	call  4000d9f0 <_Thread_Change_priority>       
4000ad24:	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();                                      
4000ad28:	40 00 0c 6c 	call  4000ded8 <_Thread_Enable_dispatch>       
4000ad2c:	b0 10 00 1d 	mov  %i5, %i0                                  
4000ad30:	30 bf ff c1 	b,a   4000ac34 <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 );              
4000ad34:	40 00 10 99 	call  4000ef98 <_Watchdog_Remove>              
4000ad38:	90 07 20 a8 	add  %i4, 0xa8, %o0                            
                                                                      
      api->schedpolicy = policy;                                      
      api->schedparam  = *param;                                      
4000ad3c:	10 bf ff cc 	b  4000ac6c <pthread_setschedparam+0x6c>       
4000ad40:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      

40008598 <pthread_testcancel>: /* * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) {
40008598:	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() )                                        
4000859c:	3b 10 00 67 	sethi  %hi(0x40019c00), %i5                    
400085a0:	ba 17 63 10 	or  %i5, 0x310, %i5	! 40019f10 <_Per_CPU_Information>
400085a4:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
400085a8:	80 a0 60 00 	cmp  %g1, 0                                    
400085ac:	12 80 00 16 	bne  40008604 <pthread_testcancel+0x6c>        <== NEVER TAKEN
400085b0:	03 10 00 66 	sethi  %hi(0x40019800), %g1                    
    return;                                                           
                                                                      
  thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
400085b4:	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;                  
400085b8:	c6 00 62 00 	ld  [ %g1 + 0x200 ], %g3                       
400085bc:	c4 00 a1 50 	ld  [ %g2 + 0x150 ], %g2                       
                                                                      
    ++level;                                                          
400085c0:	86 00 e0 01 	inc  %g3                                       
    _Thread_Dispatch_disable_level = level;                           
400085c4:	c6 20 62 00 	st  %g3, [ %g1 + 0x200 ]                       
                                                                      
  _Thread_Disable_dispatch();                                         
    if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
400085c8:	c2 00 a0 d8 	ld  [ %g2 + 0xd8 ], %g1                        
400085cc:	80 a0 60 00 	cmp  %g1, 0                                    
400085d0:	12 80 00 0b 	bne  400085fc <pthread_testcancel+0x64>        <== NEVER TAKEN
400085d4:	01 00 00 00 	nop                                            
400085d8:	c2 00 a0 e0 	ld  [ %g2 + 0xe0 ], %g1                        
400085dc:	80 a0 60 00 	cmp  %g1, 0                                    
400085e0:	02 80 00 07 	be  400085fc <pthread_testcancel+0x64>         
400085e4:	01 00 00 00 	nop                                            
         thread_support->cancelation_requested )                      
      cancel = true;                                                  
  _Thread_Enable_dispatch();                                          
400085e8:	40 00 0c 26 	call  4000b680 <_Thread_Enable_dispatch>       
400085ec:	b2 10 3f ff 	mov  -1, %i1	! ffffffff <LEON_REG+0x7fffffff>  
                                                                      
  if ( cancel )                                                       
    _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );        
400085f0:	f0 07 60 10 	ld  [ %i5 + 0x10 ], %i0                        
400085f4:	40 00 18 1f 	call  4000e670 <_POSIX_Thread_Exit>            
400085f8:	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();                                          
400085fc:	40 00 0c 21 	call  4000b680 <_Thread_Enable_dispatch>       
40008600:	81 e8 00 00 	restore                                        
40008604:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40008608:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000dbfc <ramdisk_allocate>: void *area_begin, uint32_t media_block_size, rtems_blkdev_bnum media_block_count, bool trace ) {
4000dbfc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  struct ramdisk *rd = malloc(sizeof(struct ramdisk));                
4000dc00:	7f ff df 1b 	call  4000586c <malloc>                        
4000dc04:	90 10 20 10 	mov  0x10, %o0                                 
                                                                      
  if (rd == NULL) {                                                   
4000dc08:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000dc0c:	02 80 00 0b 	be  4000dc38 <ramdisk_allocate+0x3c>           <== NEVER TAKEN
4000dc10:	80 a6 20 00 	cmp  %i0, 0                                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if (area_begin == NULL) {                                           
4000dc14:	02 80 00 0b 	be  4000dc40 <ramdisk_allocate+0x44>           
4000dc18:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
      return NULL;                                                    
    }                                                                 
    rd->malloced = true;                                              
  } else {                                                            
    rd->malloced = false;                                             
4000dc1c:	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;                                             
4000dc20:	82 10 20 01 	mov  1, %g1                                    
    }                                                                 
    rd->malloced = true;                                              
  } else {                                                            
    rd->malloced = false;                                             
  }                                                                   
  rd->block_size = media_block_size;                                  
4000dc24:	f2 27 40 00 	st  %i1, [ %i5 ]                               
  rd->block_num = media_block_count;                                  
4000dc28:	f4 27 60 04 	st  %i2, [ %i5 + 4 ]                           
  rd->area = area_begin;                                              
4000dc2c:	f0 27 60 08 	st  %i0, [ %i5 + 8 ]                           
  rd->trace = trace;                                                  
4000dc30:	f6 2f 60 0e 	stb  %i3, [ %i5 + 0xe ]                        
  rd->initialized = true;                                             
4000dc34:	c2 2f 60 0c 	stb  %g1, [ %i5 + 0xc ]                        
                                                                      
  return rd;                                                          
}                                                                     
4000dc38:	81 c7 e0 08 	ret                                            
4000dc3c:	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);         
4000dc40:	7f ff dd 8c 	call  40005270 <calloc>                        
4000dc44:	92 10 00 19 	mov  %i1, %o1                                  
    if (area_begin == NULL) {                                         
4000dc48:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000dc4c:	02 80 00 04 	be  4000dc5c <ramdisk_allocate+0x60>           <== NEVER TAKEN
4000dc50:	82 10 20 01 	mov  1, %g1                                    
      free(rd);                                                       
                                                                      
      return NULL;                                                    
    }                                                                 
    rd->malloced = true;                                              
4000dc54:	10 bf ff f4 	b  4000dc24 <ramdisk_allocate+0x28>            
4000dc58:	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);                                                       
4000dc5c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4000dc60:	7f ff dd bb 	call  4000534c <free>                          <== NOT EXECUTED
4000dc64:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
                                                                      
      return NULL;                                                    
4000dc68:	30 bf ff f4 	b,a   4000dc38 <ramdisk_allocate+0x3c>         <== NOT EXECUTED
                                                                      

4000dc6c <ramdisk_free>: return rd; } void ramdisk_free(ramdisk *rd) {
4000dc6c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (rd != NULL) {                                                   
4000dc70:	80 a6 20 00 	cmp  %i0, 0                                    
4000dc74:	02 80 00 0c 	be  4000dca4 <ramdisk_free+0x38>               <== NEVER TAKEN
4000dc78:	01 00 00 00 	nop                                            
    if (rd->malloced) {                                               
4000dc7c:	c2 0e 20 0d 	ldub  [ %i0 + 0xd ], %g1                       
4000dc80:	80 a0 60 00 	cmp  %g1, 0                                    
4000dc84:	12 80 00 04 	bne  4000dc94 <ramdisk_free+0x28>              
4000dc88:	01 00 00 00 	nop                                            
      free(rd->area);                                                 
    }                                                                 
    free(rd);                                                         
4000dc8c:	7f ff dd b0 	call  4000534c <free>                          
4000dc90:	81 e8 00 00 	restore                                        
                                                                      
void ramdisk_free(ramdisk *rd)                                        
{                                                                     
  if (rd != NULL) {                                                   
    if (rd->malloced) {                                               
      free(rd->area);                                                 
4000dc94:	7f ff dd ae 	call  4000534c <free>                          
4000dc98:	d0 06 20 08 	ld  [ %i0 + 8 ], %o0                           
    }                                                                 
    free(rd);                                                         
4000dc9c:	7f ff dd ac 	call  4000534c <free>                          
4000dca0:	81 e8 00 00 	restore                                        
4000dca4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000dca8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000ecc0 <ramdisk_initialize>: rtems_device_driver ramdisk_initialize( rtems_device_major_number major, rtems_device_minor_number minor __attribute__((unused)), void *arg __attribute__((unused))) {
4000ecc0:	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();                                  
4000ecc4:	7f ff da 06 	call  400054dc <rtems_disk_io_initialize>      
4000ecc8:	a0 10 00 18 	mov  %i0, %l0                                  
    if (rc != RTEMS_SUCCESSFUL)                                       
4000eccc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000ecd0:	02 80 00 04 	be  4000ece0 <ramdisk_initialize+0x20>         <== ALWAYS TAKEN
4000ecd4:	23 10 00 9e 	sethi  %hi(0x40027800), %l1                    
            }                                                         
            r->initialized = false;                                   
        }                                                             
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
4000ecd8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ecdc:	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));
4000ece0:	fa 04 60 2c 	ld  [ %l1 + 0x2c ], %i5                        
4000ece4:	92 10 20 10 	mov  0x10, %o1                                 
4000ece8:	7f ff dd e5 	call  4000647c <calloc>                        
4000ecec:	90 10 00 1d 	mov  %i5, %o0                                  
    r->trace = false;                                                 
4000ecf0:	c0 2a 20 0e 	clrb  [ %o0 + 0xe ]                            
    for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)  
4000ecf4:	80 a7 60 00 	cmp  %i5, 0                                    
4000ecf8:	02 80 00 2e 	be  4000edb0 <ramdisk_initialize+0xf0>         <== NEVER TAKEN
4000ecfc:	b6 10 00 08 	mov  %o0, %i3                                  
4000ed00:	35 10 00 9e 	sethi  %hi(0x40027800), %i2                    
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
4000ed04:	39 0b d9 19 	sethi  %hi(0x2f646400), %i4                    
4000ed08:	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, 
4000ed0c:	25 10 00 3b 	sethi  %hi(0x4000ec00), %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++)  
4000ed10:	b4 16 a0 30 	or  %i2, 0x30, %i2                             
4000ed14:	b2 10 20 00 	clr  %i1                                       
4000ed18:	a2 14 60 2c 	or  %l1, 0x2c, %l1                             
    {                                                                 
        dev_t dev = rtems_filesystem_make_dev_t(major, i);            
        char name [] = RAMDISK_DEVICE_BASE_NAME "a";                  
4000ed1c:	b8 17 21 76 	or  %i4, 0x176, %i4                            
4000ed20:	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);          
4000ed24:	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, 
4000ed28:	a4 14 a1 fc 	or  %l2, 0x1fc, %l2                            
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
            r->initialized = true;                                    
4000ed2c:	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;                                
4000ed30:	d4 06 80 00 	ld  [ %i2 ], %o2                               
        r->block_num = c->block_num;                                  
4000ed34:	d6 06 a0 04 	ld  [ %i2 + 4 ], %o3                           
        if (c->location == NULL)                                      
4000ed38:	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;                 
4000ed3c:	f2 2f bf f8 	stb  %i1, [ %fp + -8 ]                         
        r->block_size = c->block_size;                                
4000ed40:	d4 26 c0 00 	st  %o2, [ %i3 ]                               
        r->block_num = c->block_num;                                  
4000ed44:	d6 26 e0 04 	st  %o3, [ %i3 + 4 ]                           
        if (c->location == NULL)                                      
4000ed48:	80 a0 60 00 	cmp  %g1, 0                                    
4000ed4c:	02 80 00 1f 	be  4000edc8 <ramdisk_initialize+0x108>        <== ALWAYS TAKEN
4000ed50:	f8 3f bf f0 	std  %i4, [ %fp + -16 ]                        
                r->initialized = true;                                
            }                                                         
        }                                                             
        else                                                          
        {                                                             
            r->malloced = false;                                      
4000ed54:	c0 2e e0 0d 	clrb  [ %i3 + 0xd ]                            <== NOT EXECUTED
            r->initialized = true;                                    
4000ed58:	f0 2e e0 0c 	stb  %i0, [ %i3 + 0xc ]                        <== NOT EXECUTED
            r->area = c->location;                                    
4000ed5c:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           <== NOT EXECUTED
        }                                                             
        rc = rtems_disk_create_phys(dev, c->block_size, c->block_num, 
4000ed60:	92 10 00 19 	mov  %i1, %o1                                  
4000ed64:	9a 10 00 1b 	mov  %i3, %o5                                  
4000ed68:	98 10 00 12 	mov  %l2, %o4                                  
4000ed6c:	e6 23 a0 5c 	st  %l3, [ %sp + 0x5c ]                        
4000ed70:	7f ff d9 3b 	call  4000525c <rtems_disk_create_phys>        
4000ed74:	90 10 00 10 	mov  %l0, %o0                                  
                                    ramdisk_ioctl, r, name);          
        if (rc != RTEMS_SUCCESSFUL)                                   
4000ed78:	80 a2 20 00 	cmp  %o0, 0                                    
4000ed7c:	22 80 00 08 	be,a   4000ed9c <ramdisk_initialize+0xdc>      <== ALWAYS TAKEN
4000ed80:	c2 04 40 00 	ld  [ %l1 ], %g1                               
        {                                                             
            if (r->malloced)                                          
4000ed84:	c2 0e e0 0d 	ldub  [ %i3 + 0xd ], %g1                       <== NOT EXECUTED
4000ed88:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000ed8c:	12 80 00 0b 	bne  4000edb8 <ramdisk_initialize+0xf8>        <== NOT EXECUTED
4000ed90:	01 00 00 00 	nop                                            <== NOT EXECUTED
            {                                                         
                free(r->area);                                        
            }                                                         
            r->initialized = false;                                   
4000ed94:	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++)  
4000ed98:	c2 04 40 00 	ld  [ %l1 ], %g1                               <== NOT EXECUTED
4000ed9c:	b2 06 60 01 	inc  %i1                                       
4000eda0:	b4 06 a0 0c 	add  %i2, 0xc, %i2                             
4000eda4:	80 a0 40 19 	cmp  %g1, %i1                                  
4000eda8:	18 bf ff e2 	bgu  4000ed30 <ramdisk_initialize+0x70>        <== NEVER TAKEN
4000edac:	b6 06 e0 10 	add  %i3, 0x10, %i3                            
                free(r->area);                                        
            }                                                         
            r->initialized = false;                                   
        }                                                             
    }                                                                 
    return RTEMS_SUCCESSFUL;                                          
4000edb0:	81 c7 e0 08 	ret                                            
4000edb4:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                    ramdisk_ioctl, r, name);          
        if (rc != RTEMS_SUCCESSFUL)                                   
        {                                                             
            if (r->malloced)                                          
            {                                                         
                free(r->area);                                        
4000edb8:	7f ff dd e8 	call  40006558 <free>                          <== NOT EXECUTED
4000edbc:	d0 06 e0 08 	ld  [ %i3 + 8 ], %o0                           <== NOT EXECUTED
            }                                                         
            r->initialized = false;                                   
4000edc0:	10 bf ff f6 	b  4000ed98 <ramdisk_initialize+0xd8>          <== NOT EXECUTED
4000edc4:	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);           
4000edc8:	92 10 00 0a 	mov  %o2, %o1                                  
4000edcc:	90 10 00 0b 	mov  %o3, %o0                                  
4000edd0:	d4 3f bf e8 	std  %o2, [ %fp + -24 ]                        
4000edd4:	40 00 4f e5 	call  40022d68 <.umul>                         
4000edd8:	f0 2e e0 0d 	stb  %i0, [ %i3 + 0xd ]                        
4000eddc:	7f ff df 7c 	call  40006bcc <malloc>                        
4000ede0:	01 00 00 00 	nop                                            
4000ede4:	d0 26 e0 08 	st  %o0, [ %i3 + 8 ]                           
            if (r->area == NULL) /* No enough memory for this disk */ 
4000ede8:	80 a2 20 00 	cmp  %o0, 0                                    
4000edec:	02 bf ff ea 	be  4000ed94 <ramdisk_initialize+0xd4>         <== NEVER TAKEN
4000edf0:	d4 1f bf e8 	ldd  [ %fp + -24 ], %o2                        
                r->initialized = false;                               
                continue;                                             
            }                                                         
            else                                                      
            {                                                         
                r->initialized = true;                                
4000edf4:	10 bf ff db 	b  4000ed60 <ramdisk_initialize+0xa0>          
4000edf8:	f0 2e e0 0c 	stb  %i0, [ %i3 + 0xc ]                        
                                                                      

4000dab4 <ramdisk_ioctl>: return 0; } int ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp) {
4000dab4:	9d e3 bf a0 	save  %sp, -96, %sp                            
    struct ramdisk *rd = rtems_disk_get_driver_data(dd);              
                                                                      
    switch (req)                                                      
4000dab8:	05 08 00 10 	sethi  %hi(0x20004000), %g2                    
    return 0;                                                         
}                                                                     
                                                                      
int                                                                   
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)        
{                                                                     
4000dabc:	b8 10 00 1a 	mov  %i2, %i4                                  
    struct ramdisk *rd = rtems_disk_get_driver_data(dd);              
                                                                      
    switch (req)                                                      
4000dac0:	84 10 a2 07 	or  %g2, 0x207, %g2                            
4000dac4:	80 a6 40 02 	cmp  %i1, %g2                                  
4000dac8:	02 80 00 09 	be  4000daec <ramdisk_ioctl+0x38>              
4000dacc:	f6 06 20 3c 	ld  [ %i0 + 0x3c ], %i3                        
4000dad0:	05 30 06 10 	sethi  %hi(0xc0184000), %g2                    
4000dad4:	84 10 a2 01 	or  %g2, 0x201, %g2	! c0184201 <LEON_REG+0x40184201>
4000dad8:	80 a6 40 02 	cmp  %i1, %g2                                  
4000dadc:	22 80 00 0e 	be,a   4000db14 <ramdisk_ioctl+0x60>           
4000dae0:	c2 06 80 00 	ld  [ %i2 ], %g1                               
              ramdisk_free(rd);                                       
            }                                                         
            break;                                                    
                                                                      
        default:                                                      
            return rtems_blkdev_ioctl (dd, req, argp);                
4000dae4:	40 00 0b 08 	call  40010704 <rtems_blkdev_ioctl>            
4000dae8:	81 e8 00 00 	restore                                        
            }                                                         
            break;                                                    
        }                                                             
                                                                      
        case RTEMS_BLKIO_DELETED:                                     
            if (rd->free_at_delete_request) {                         
4000daec:	c2 0e e0 0f 	ldub  [ %i3 + 0xf ], %g1                       
4000daf0:	80 a0 60 00 	cmp  %g1, 0                                    
4000daf4:	12 80 00 3f 	bne  4000dbf0 <ramdisk_ioctl+0x13c>            
4000daf8:	01 00 00 00 	nop                                            
        default:                                                      
            return rtems_blkdev_ioctl (dd, req, argp);                
            break;                                                    
    }                                                                 
                                                                      
    errno = EINVAL;                                                   
4000dafc:	40 00 1d ff 	call  400152f8 <__errno>                       
4000db00:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  
4000db04:	82 10 20 16 	mov  0x16, %g1                                 
4000db08:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    return -1;                                                        
}                                                                     
4000db0c:	81 c7 e0 08 	ret                                            
4000db10:	81 e8 00 00 	restore                                        
    {                                                                 
        case RTEMS_BLKIO_REQUEST:                                     
        {                                                             
            rtems_blkdev_request *r = argp;                           
                                                                      
            switch (r->req)                                           
4000db14:	80 a0 60 00 	cmp  %g1, 0                                    
4000db18:	12 80 00 1c 	bne  4000db88 <ramdisk_ioctl+0xd4>             
4000db1c:	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++)           
4000db20:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
4000db24:	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;                                         
4000db28:	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++)           
4000db2c:	80 a0 60 00 	cmp  %g1, 0                                    
4000db30:	02 80 00 0f 	be  4000db6c <ramdisk_ioctl+0xb8>              <== NEVER TAKEN
4000db34:	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);
4000db38:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000db3c:	d2 06 c0 00 	ld  [ %i3 ], %o1                               
4000db40:	40 00 2b 77 	call  4001891c <.umul>                         
4000db44:	f2 07 60 08 	ld  [ %i5 + 8 ], %i1                           
4000db48:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
4000db4c:	92 06 00 08 	add  %i0, %o0, %o1                             
4000db50:	40 00 20 21 	call  40015bd4 <memcpy>                        
4000db54:	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++)           
4000db58:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
4000db5c:	b4 06 a0 01 	inc  %i2                                       
4000db60:	80 a6 80 01 	cmp  %i2, %g1                                  
4000db64:	0a bf ff f5 	bcs  4000db38 <ramdisk_ioctl+0x84>             <== NEVER TAKEN
4000db68:	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);                                          
4000db6c:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
4000db70:	90 10 00 1c 	mov  %i4, %o0                                  
4000db74:	92 10 20 00 	clr  %o1                                       
4000db78:	9f c0 40 00 	call  %g1                                      
4000db7c:	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);                      
4000db80:	81 c7 e0 08 	ret                                            
4000db84:	81 e8 00 00 	restore                                        
    {                                                                 
        case RTEMS_BLKIO_REQUEST:                                     
        {                                                             
            rtems_blkdev_request *r = argp;                           
                                                                      
            switch (r->req)                                           
4000db88:	12 bf ff dd 	bne  4000dafc <ramdisk_ioctl+0x48>             <== NEVER TAKEN
4000db8c:	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++)           
4000db90:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
}                                                                     
                                                                      
static int                                                            
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)          
{                                                                     
    uint8_t *to = rd->area;                                           
4000db94:	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++)           
4000db98:	80 a0 60 00 	cmp  %g1, 0                                    
4000db9c:	02 bf ff f4 	be  4000db6c <ramdisk_ioctl+0xb8>              <== NEVER TAKEN
4000dba0:	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);
4000dba4:	d0 07 40 00 	ld  [ %i5 ], %o0                               
4000dba8:	d2 06 c0 00 	ld  [ %i3 ], %o1                               
4000dbac:	40 00 2b 5c 	call  4001891c <.umul>                         
4000dbb0:	b4 06 a0 01 	inc  %i2                                       
4000dbb4:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
4000dbb8:	d4 07 60 04 	ld  [ %i5 + 4 ], %o2                           
4000dbbc:	40 00 20 06 	call  40015bd4 <memcpy>                        
4000dbc0:	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++)           
4000dbc4:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
4000dbc8:	80 a6 80 01 	cmp  %i2, %g1                                  
4000dbcc:	0a bf ff f6 	bcs  4000dba4 <ramdisk_ioctl+0xf0>             
4000dbd0:	ba 07 60 10 	add  %i5, 0x10, %i5                            
4000dbd4:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
4000dbd8:	90 10 00 1c 	mov  %i4, %o0                                  
4000dbdc:	92 10 20 00 	clr  %o1                                       
4000dbe0:	9f c0 40 00 	call  %g1                                      
4000dbe4:	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);                      
4000dbe8:	81 c7 e0 08 	ret                                            
4000dbec:	81 e8 00 00 	restore                                        
            break;                                                    
        }                                                             
                                                                      
        case RTEMS_BLKIO_DELETED:                                     
            if (rd->free_at_delete_request) {                         
              ramdisk_free(rd);                                       
4000dbf0:	40 00 00 1f 	call  4000dc6c <ramdisk_free>                  
4000dbf4:	90 10 00 1b 	mov  %i3, %o0                                  
4000dbf8:	30 bf ff c1 	b,a   4000dafc <ramdisk_ioctl+0x48>            
                                                                      

4000dcac <ramdisk_register>: rtems_blkdev_bnum media_block_count, bool trace, const char *disk, dev_t *dev_ptr ) {
4000dcac:	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);             
4000dcb0:	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;                                
4000dcb4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  ramdisk *rd = NULL;                                                 
  dev_t dev = 0;                                                      
                                                                      
  sc = rtems_io_register_driver(0, &ramdisk_ops, &major);             
4000dcb8:	94 07 bf fc 	add  %fp, -4, %o2                              
4000dcbc:	13 10 00 6d 	sethi  %hi(0x4001b400), %o1                    
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return RTEMS_UNSATISFIED;                                         
4000dcc0:	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);             
4000dcc4:	7f ff f1 50 	call  4000a204 <rtems_io_register_driver>      
4000dcc8:	92 12 60 08 	or  %o1, 8, %o1                                
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000dccc:	80 a2 20 00 	cmp  %o0, 0                                    
4000dcd0:	02 80 00 04 	be  4000dce0 <ramdisk_register+0x34>           <== ALWAYS TAKEN
4000dcd4:	96 10 00 1a 	mov  %i2, %o3                                  
  }                                                                   
                                                                      
  *dev_ptr = dev;                                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000dcd8:	81 c7 e0 08 	ret                                            
4000dcdc:	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);
4000dce0:	92 10 00 18 	mov  %i0, %o1                                  
4000dce4:	7f ff ff c6 	call  4000dbfc <ramdisk_allocate>              
4000dce8:	94 10 00 19 	mov  %i1, %o2                                  
  if (rd == NULL) {                                                   
4000dcec:	b4 92 20 00 	orcc  %o0, 0, %i2                              
4000dcf0:	02 80 00 14 	be  4000dd40 <ramdisk_register+0x94>           <== NEVER TAKEN
4000dcf4:	e0 07 bf fc 	ld  [ %fp + -4 ], %l0                          
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  dev = rtems_filesystem_make_dev_t(major, 0);                        
                                                                      
  sc = rtems_disk_create_phys(                                        
4000dcf8:	f6 23 a0 5c 	st  %i3, [ %sp + 0x5c ]                        
4000dcfc:	90 10 00 10 	mov  %l0, %o0                                  
4000dd00:	92 10 20 00 	clr  %o1                                       
4000dd04:	94 10 00 18 	mov  %i0, %o2                                  
4000dd08:	96 10 00 19 	mov  %i1, %o3                                  
4000dd0c:	9a 10 00 1a 	mov  %i2, %o5                                  
4000dd10:	19 10 00 36 	sethi  %hi(0x4000d800), %o4                    
4000dd14:	7f ff da 75 	call  400046e8 <rtems_disk_create_phys>        
4000dd18:	98 13 22 b4 	or  %o4, 0x2b4, %o4	! 4000dab4 <ramdisk_ioctl> 
    media_block_count,                                                
    ramdisk_ioctl,                                                    
    rd,                                                               
    disk                                                              
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
4000dd1c:	80 a2 20 00 	cmp  %o0, 0                                    
4000dd20:	12 80 00 06 	bne  4000dd38 <ramdisk_register+0x8c>          <== NEVER TAKEN
4000dd24:	01 00 00 00 	nop                                            
    rtems_io_unregister_driver(major);                                
                                                                      
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  *dev_ptr = dev;                                                     
4000dd28:	e0 27 00 00 	st  %l0, [ %i4 ]                               
4000dd2c:	c0 27 20 04 	clr  [ %i4 + 4 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000dd30:	10 bf ff ea 	b  4000dcd8 <ramdisk_register+0x2c>            
4000dd34:	ba 10 20 00 	clr  %i5                                       
    ramdisk_ioctl,                                                    
    rd,                                                               
    disk                                                              
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
    ramdisk_free(rd);                                                 
4000dd38:	7f ff ff cd 	call  4000dc6c <ramdisk_free>                  <== NOT EXECUTED
4000dd3c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
    rtems_io_unregister_driver(major);                                
4000dd40:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          <== NOT EXECUTED
4000dd44:	7f ff f1 95 	call  4000a398 <rtems_io_unregister_driver>    <== NOT EXECUTED
4000dd48:	b0 10 00 1d 	mov  %i5, %i0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  *dev_ptr = dev;                                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000dd4c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000dd50:	81 e8 00 00 	restore                                        <== NOT EXECUTED
4000dd54:	40 00 ed d0 	call  40049494 <__end+0x2bec4>                 <== NOT EXECUTED
4000dd58:	40 00 ef 6c 	call  40049b08 <__end+0x2c538>                 <== NOT EXECUTED
4000dd5c:	40 00 ef 64 	call  40049aec <__end+0x2c51c>                 <== NOT EXECUTED
4000dd60:	40 00 ef 50 	call  40049aa0 <__end+0x2c4d0>                 <== NOT EXECUTED
4000dd64:	40 00 ef 50 	call  40049aa4 <__end+0x2c4d4>                 <== NOT EXECUTED
4000dd68:	40 00 ef 50 	call  40049aa8 <__end+0x2c4d8>                 <== NOT EXECUTED
4000dd6c:	40 00 ef 50 	call  40049aac <__end+0x2c4dc>                 <== NOT EXECUTED
4000dd70:	40 00 ef 1c 	call  400499e0 <__end+0x2c410>                 <== NOT EXECUTED
4000dd74:	40 00 ef 08 	call  40049994 <__end+0x2c3c4>                 <== NOT EXECUTED
4000dd78:	40 00 ef 08 	call  40049998 <__end+0x2c3c8>                 <== NOT EXECUTED
4000dd7c:	40 00 ef 08 	call  4004999c <__end+0x2c3cc>                 <== NOT EXECUTED
4000dd80:	40 00 ee 18 	call  400495e0 <__end+0x2c010>                 <== NOT EXECUTED
4000dd84:	40 00 ee 08 	call  400495a4 <__end+0x2bfd4>                 <== NOT EXECUTED
4000dd88:	40 00 ee 08 	call  400495a8 <__end+0x2bfd8>                 <== NOT EXECUTED
4000dd8c:	40 00 ee e4 	call  4004991c <__end+0x2c34c>                 <== NOT EXECUTED
4000dd90:	40 00 ee e4 	call  40049920 <__end+0x2c350>                 <== NOT EXECUTED
4000dd94:	40 00 ee e4 	call  40049924 <__end+0x2c354>                 <== NOT EXECUTED
4000dd98:	40 00 ee e4 	call  40049928 <__end+0x2c358>                 <== NOT EXECUTED
4000dd9c:	40 00 ee b0 	call  4004985c <__end+0x2c28c>                 <== NOT EXECUTED
4000dda0:	40 00 ee 9c 	call  40049810 <__end+0x2c240>                 <== NOT EXECUTED
4000dda4:	40 00 ee 9c 	call  40049814 <__end+0x2c244>                 <== NOT EXECUTED
4000dda8:	40 00 ee 9c 	call  40049818 <__end+0x2c248>                 <== NOT EXECUTED
4000ddac:	40 01 04 1c 	call  4004ee1c <__end+0x3184c>                 <== NOT EXECUTED
4000ddb0:	40 01 04 1c 	call  4004ee20 <__end+0x31850>                 <== NOT EXECUTED
4000ddb4:	40 01 05 44 	call  4004f2c4 <__end+0x31cf4>                 <== NOT EXECUTED
4000ddb8:	40 01 05 6c 	call  4004f368 <__end+0x31d98>                 <== NOT EXECUTED
4000ddbc:	40 01 05 6c 	call  4004f36c <__end+0x31d9c>                 <== NOT EXECUTED
4000ddc0:	40 01 05 6c 	call  4004f370 <__end+0x31da0>                 <== NOT EXECUTED
4000ddc4:	40 01 04 1c 	call  4004ee34 <__end+0x31864>                 <== NOT EXECUTED
4000ddc8:	40 01 05 34 	call  4004f298 <__end+0x31cc8>                 <== NOT EXECUTED
4000ddcc:	40 01 05 2c 	call  4004f27c <__end+0x31cac>                 <== NOT EXECUTED
4000ddd0:	40 01 05 74 	call  4004f3a0 <__end+0x31dd0>                 <== NOT EXECUTED
4000ddd4:	40 01 04 1c 	call  4004ee44 <__end+0x31874>                 <== NOT EXECUTED
                                                                      

4001c8d0 <read>: ssize_t read( int fd, void *buffer, size_t count ) {
4001c8d0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t *iop;                                                 
                                                                      
  rtems_libio_check_fd( fd );                                         
4001c8d4:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
4001c8d8:	c2 00 61 a4 	ld  [ %g1 + 0x1a4 ], %g1	! 4001f5a4 <rtems_libio_number_iops>
4001c8dc:	80 a6 00 01 	cmp  %i0, %g1                                  
4001c8e0:	1a 80 00 18 	bcc  4001c940 <read+0x70>                      
4001c8e4:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
  iop = rtems_libio_iop( fd );                                        
4001c8e8:	d0 00 61 24 	ld  [ %g1 + 0x124 ], %o0	! 40020124 <rtems_libio_iops>
4001c8ec:	83 2e 20 03 	sll  %i0, 3, %g1                               
4001c8f0:	b1 2e 20 06 	sll  %i0, 6, %i0                               
4001c8f4:	b0 26 00 01 	sub  %i0, %g1, %i0                             
4001c8f8:	90 02 00 18 	add  %o0, %i0, %o0                             
  rtems_libio_check_is_open( iop );                                   
4001c8fc:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
4001c900:	80 88 61 00 	btst  0x100, %g1                               
4001c904:	02 80 00 0f 	be  4001c940 <read+0x70>                       
4001c908:	80 a6 60 00 	cmp  %i1, 0                                    
  rtems_libio_check_buffer( buffer );                                 
4001c90c:	02 80 00 13 	be  4001c958 <read+0x88>                       <== NEVER TAKEN
4001c910:	80 a6 a0 00 	cmp  %i2, 0                                    
  rtems_libio_check_count( count );                                   
4001c914:	02 80 00 0f 	be  4001c950 <read+0x80>                       
4001c918:	b0 10 20 00 	clr  %i0                                       
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
4001c91c:	80 88 60 02 	btst  2, %g1                                   
4001c920:	02 80 00 08 	be  4001c940 <read+0x70>                       
4001c924:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  /*                                                                  
   *  Now process the read().                                         
   */                                                                 
  return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );     
4001c928:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        
4001c92c:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
4001c930:	9f c0 40 00 	call  %g1                                      
4001c934:	94 10 00 1a 	mov  %i2, %o2                                  
}                                                                     
4001c938:	81 c7 e0 08 	ret                                            
4001c93c:	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 );
4001c940:	7f ff d0 00 	call  40010940 <__errno>                       
4001c944:	b0 10 3f ff 	mov  -1, %i0                                   
4001c948:	82 10 20 09 	mov  9, %g1                                    
4001c94c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001c950:	81 c7 e0 08 	ret                                            
4001c954:	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 );                                 
4001c958:	7f ff cf fa 	call  40010940 <__errno>                       <== NOT EXECUTED
4001c95c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001c960:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4001c964:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001c968:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c96c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40005854 <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) {
40005854:	9d e3 bf 98 	save  %sp, -104, %sp                           
    int                  i;                                           
    rtems_sector_data_t *sector = NULL;                               
40005858:	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)
{                                                                     
4000585c:	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))          
40005860:	80 a6 a0 00 	cmp  %i2, 0                                    
40005864:	02 80 00 16 	be  400058bc <read_extended_partition+0x68>    <== NEVER TAKEN
40005868:	b0 10 20 19 	mov  0x19, %i0                                 
4000586c:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
40005870:	80 a0 60 00 	cmp  %g1, 0                                    
40005874:	02 80 00 12 	be  400058bc <read_extended_partition+0x68>    <== NEVER TAKEN
40005878:	90 10 00 1d 	mov  %i5, %o0                                  
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    /* get start sector of current extended partition */              
    here = ext_part->start;                                           
4000587c:	e0 06 a0 04 	ld  [ %i2 + 4 ], %l0                           
    if (sector == NULL)                                               
    {                                                                 
        return RTEMS_INTERNAL_ERROR;                                  
    }                                                                 
                                                                      
    off = sector_num * RTEMS_IDE_SECTOR_SIZE;                         
40005880:	b9 2c 20 09 	sll  %l0, 9, %i4                               
    new_off = lseek(fd, off, SEEK_SET);                               
40005884:	92 10 20 00 	clr  %o1                                       
40005888:	94 10 00 1c 	mov  %i4, %o2                                  
4000588c:	40 00 04 57 	call  400069e8 <lseek>                         
40005890:	96 10 20 00 	clr  %o3                                       
    if (new_off != off) {                                             
40005894:	80 a2 20 00 	cmp  %o0, 0                                    
40005898:	02 80 00 0b 	be  400058c4 <read_extended_partition+0x70>    <== ALWAYS TAKEN
4000589c:	80 a7 00 09 	cmp  %i4, %o1                                  
        return RTEMS_IO_ERROR;                                        
400058a0:	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)                                                   
400058a4:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          <== NOT EXECUTED
400058a8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400058ac:	02 80 00 41 	be  400059b0 <read_extended_partition+0x15c>   <== NOT EXECUTED
400058b0:	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);                                                     
400058b4:	40 00 03 29 	call  40006558 <free>                          <== NOT EXECUTED
400058b8:	01 00 00 00 	nop                                            <== NOT EXECUTED
400058bc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400058c0:	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) {                                             
400058c4:	12 bf ff f8 	bne  400058a4 <read_extended_partition+0x50>   <== NEVER TAKEN
400058c8:	b0 10 20 1b 	mov  0x1b, %i0                                 
400058cc:	90 10 00 1d 	mov  %i5, %o0                                  
400058d0:	92 10 00 10 	mov  %l0, %o1                                  
400058d4:	7f ff ff 7c 	call  400056c4 <get_sector.part.0>             
400058d8:	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)                                       
400058dc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400058e0:	12 bf ff f1 	bne  400058a4 <read_extended_partition+0x50>   <== NEVER TAKEN
400058e4:	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) &&    
400058e8:	c2 0a 22 02 	ldub  [ %o0 + 0x202 ], %g1                     
400058ec:	80 a0 60 55 	cmp  %g1, 0x55                                 
400058f0:	22 80 00 06 	be,a   40005908 <read_extended_partition+0xb4> <== ALWAYS TAKEN
400058f4:	c2 0a 22 03 	ldub  [ %o0 + 0x203 ], %g1                     
        return rc;                                                    
    }                                                                 
                                                                      
    if (!msdos_signature_check(sector))                               
    {                                                                 
        free(sector);                                                 
400058f8:	40 00 03 18 	call  40006558 <free>                          <== NOT EXECUTED
400058fc:	b0 10 20 19 	mov  0x19, %i0                                 <== NOT EXECUTED
40005900:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005904:	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) &&    
40005908:	80 a0 60 aa 	cmp  %g1, 0xaa                                 
4000590c:	12 bf ff fb 	bne  400058f8 <read_extended_partition+0xa4>   <== NEVER TAKEN
40005910:	b6 02 21 d2 	add  %o0, 0x1d2, %i3                           
40005914:	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)
40005918:	a2 06 a0 10 	add  %i2, 0x10, %l1                            
4000591c:	90 06 ff f0 	add  %i3, -16, %o0                             
40005920:	7f ff ff 80 	call  40005720 <data_to_part_desc.part.1>      
40005924:	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)                                   
40005928:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000592c:	12 80 00 1f 	bne  400059a8 <read_extended_partition+0x154>  <== NEVER TAKEN
40005930:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
        {                                                             
            free(sector);                                             
            return rc;                                                
        }                                                             
                                                                      
        if (new_part_desc == NULL)                                    
40005934:	80 a2 a0 00 	cmp  %o2, 0                                    
40005938:	22 80 00 19 	be,a   4000599c <read_extended_partition+0x148>
4000593c:	b8 07 20 04 	add  %i4, 4, %i4                               
        {                                                             
            data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;              
            continue;                                                 
        }                                                             
                                                                      
        ext_part->sub_part[i] = new_part_desc;                        
40005940:	d4 27 20 18 	st  %o2, [ %i4 + 0x18 ]                        
        new_part_desc->ext_part = ext_part;                           
        new_part_desc->disk_desc = ext_part->disk_desc;               
40005944:	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));
40005948:	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;                           
4000594c:	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))                     
40005950:	84 08 a0 7f 	and  %g2, 0x7f, %g2                            
40005954:	80 a0 a0 05 	cmp  %g2, 5                                    
40005958:	02 80 00 18 	be  400059b8 <read_extended_partition+0x164>   
4000595c:	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;
40005960:	c6 00 60 24 	ld  [ %g1 + 0x24 ], %g3                        
            new_part_desc->log_id = ++disk_desc->last_log_id;         
            new_part_desc->start += here;                             
40005964:	de 02 a0 04 	ld  [ %o2 + 4 ], %o7                           
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40005968:	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;         
4000596c:	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;
40005970:	86 00 e0 0a 	add  %g3, 0xa, %g3                             
            new_part_desc->log_id = ++disk_desc->last_log_id;         
40005974:	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;
40005978:	87 28 e0 02 	sll  %g3, 2, %g3                               
4000597c:	d4 20 40 03 	st  %o2, [ %g1 + %g3 ]                         
            new_part_desc->log_id = ++disk_desc->last_log_id;         
40005980:	c4 2a a0 02 	stb  %g2, [ %o2 + 2 ]                          
            new_part_desc->start += here;                             
40005984:	82 04 00 0f 	add  %l0, %o7, %g1                             
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40005988:	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;                             
4000598c:	c2 22 a0 04 	st  %g1, [ %o2 + 4 ]                           
            new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
40005990:	82 00 80 01 	add  %g2, %g1, %g1                             
40005994:	c2 22 a0 0c 	st  %g1, [ %o2 + 0xc ]                         
40005998:	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++)
4000599c:	80 a7 00 11 	cmp  %i4, %l1                                  
400059a0:	12 bf ff df 	bne  4000591c <read_extended_partition+0xc8>   
400059a4:	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);                                                     
400059a8:	40 00 02 ec 	call  40006558 <free>                          
400059ac:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
400059b0:	81 c7 e0 08 	ret                                            
400059b4:	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;                            
400059b8:	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;                  
400059bc:	c0 2a a0 02 	clrb  [ %o2 + 2 ]                              
            new_part_desc->start += start;                            
400059c0:	82 00 40 19 	add  %g1, %i1, %g1                             
            read_extended_partition(fd, start, new_part_desc);        
400059c4:	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;                            
400059c8:	c2 22 a0 04 	st  %g1, [ %o2 + 4 ]                           
            read_extended_partition(fd, start, new_part_desc);        
400059cc:	7f ff ff a2 	call  40005854 <read_extended_partition>       
400059d0:	92 10 00 19 	mov  %i1, %o1                                  
400059d4:	10 bf ff f2 	b  4000599c <read_extended_partition+0x148>    
400059d8:	b8 07 20 04 	add  %i4, 4, %i4                               
                                                                      

40005acc <readv>: ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) {
40005acc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int            v;                                                   
  int            bytes;                                               
  rtems_libio_t *iop;                                                 
  bool           all_zeros;                                           
                                                                      
  rtems_libio_check_fd( fd );                                         
40005ad0:	03 10 00 62 	sethi  %hi(0x40018800), %g1                    
40005ad4:	c2 00 61 d4 	ld  [ %g1 + 0x1d4 ], %g1	! 400189d4 <rtems_libio_number_iops>
40005ad8:	80 a6 00 01 	cmp  %i0, %g1                                  
40005adc:	1a 80 00 45 	bcc  40005bf0 <readv+0x124>                    
40005ae0:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
  iop = rtems_libio_iop( fd );                                        
40005ae4:	f6 00 61 30 	ld  [ %g1 + 0x130 ], %i3	! 40019530 <rtems_libio_iops>
40005ae8:	83 2e 20 03 	sll  %i0, 3, %g1                               
40005aec:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40005af0:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40005af4:	b6 06 c0 18 	add  %i3, %i0, %i3                             
  rtems_libio_check_is_open( iop );                                   
40005af8:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
40005afc:	80 88 61 00 	btst  0x100, %g1                               
40005b00:	02 80 00 3c 	be  40005bf0 <readv+0x124>                     
40005b04:	80 88 60 02 	btst  2, %g1                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
40005b08:	02 80 00 3a 	be  40005bf0 <readv+0x124>                     <== NEVER TAKEN
40005b0c:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
40005b10:	02 80 00 32 	be  40005bd8 <readv+0x10c>                     
40005b14:	80 a6 a0 00 	cmp  %i2, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
40005b18:	04 80 00 30 	ble  40005bd8 <readv+0x10c>                    
40005b1c:	80 a6 a4 00 	cmp  %i2, 0x400                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
40005b20:	14 80 00 2e 	bg  40005bd8 <readv+0x10c>                     <== NEVER TAKEN
40005b24:	b5 2e a0 03 	sll  %i2, 3, %i2                               
 *                                                                    
 *  OpenGroup URL:                                                    
 *                                                                    
 *  http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
 */                                                                   
ssize_t readv(                                                        
40005b28:	82 10 20 00 	clr  %g1                                       
40005b2c:	ba 10 20 01 	mov  1, %i5                                    
40005b30:	10 80 00 03 	b  40005b3c <readv+0x70>                       
40005b34:	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;                                          
40005b38:	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 )                                       
40005b3c:	c6 06 40 01 	ld  [ %i1 + %g1 ], %g3                         
40005b40:	80 a0 e0 00 	cmp  %g3, 0                                    
40005b44:	02 80 00 25 	be  40005bd8 <readv+0x10c>                     
40005b48:	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;                                          
40005b4c:	c6 01 20 04 	ld  [ %g4 + 4 ], %g3                           
40005b50:	88 00 c0 02 	add  %g3, %g2, %g4                             
    if ( total < old )                                                
40005b54:	80 a1 00 02 	cmp  %g4, %g2                                  
40005b58:	06 80 00 20 	bl  40005bd8 <readv+0x10c>                     
40005b5c:	82 00 60 08 	add  %g1, 8, %g1                               
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
      all_zeros = false;                                              
40005b60:	80 a0 00 03 	cmp  %g0, %g3                                  
40005b64:	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++ ) {                           
40005b68:	80 a0 40 1a 	cmp  %g1, %i2                                  
40005b6c:	12 bf ff f3 	bne  40005b38 <readv+0x6c>                     
40005b70:	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 ) {                                          
40005b74:	80 8f 60 ff 	btst  0xff, %i5                                
40005b78:	12 80 00 16 	bne  40005bd0 <readv+0x104>                    
40005b7c:	b0 10 20 00 	clr  %i0                                       
40005b80:	ba 10 20 00 	clr  %i5                                       
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
    bytes = (*iop->pathinfo.handlers->read_h)(                        
40005b84:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
 *                                                                    
 *  OpenGroup URL:                                                    
 *                                                                    
 *  http://www.opengroup.org/onlinepubs/009695399/functions/readv.html
 */                                                                   
ssize_t readv(                                                        
40005b88:	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)(                        
40005b8c:	d2 06 40 1d 	ld  [ %i1 + %i5 ], %o1                         
40005b90:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40005b94:	d4 07 20 04 	ld  [ %i4 + 4 ], %o2                           
40005b98:	9f c0 40 00 	call  %g1                                      
40005b9c:	90 10 00 1b 	mov  %i3, %o0                                  
      iop,                                                            
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
40005ba0:	80 a2 20 00 	cmp  %o0, 0                                    
40005ba4:	26 80 00 0b 	bl,a   40005bd0 <readv+0x104>                  <== NEVER TAKEN
40005ba8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
40005bac:	32 80 00 02 	bne,a   40005bb4 <readv+0xe8>                  <== ALWAYS TAKEN
40005bb0:	b0 06 00 08 	add  %i0, %o0, %i0                             
      total       += bytes;                                           
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
40005bb4:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
40005bb8:	80 a2 00 01 	cmp  %o0, %g1                                  
40005bbc:	12 80 00 05 	bne  40005bd0 <readv+0x104>                    <== NEVER TAKEN
40005bc0:	ba 07 60 08 	add  %i5, 8, %i5                               
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the readv().                                        
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
40005bc4:	80 a6 80 1d 	cmp  %i2, %i5                                  
40005bc8:	32 bf ff f0 	bne,a   40005b88 <readv+0xbc>                  
40005bcc:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
40005bd0:	81 c7 e0 08 	ret                                            
40005bd4:	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 );                 
40005bd8:	40 00 2d ab 	call  40011284 <__errno>                       
40005bdc:	b0 10 3f ff 	mov  -1, %i0                                   
40005be0:	82 10 20 16 	mov  0x16, %g1                                 
40005be4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40005be8:	81 c7 e0 08 	ret                                            
40005bec:	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 );
40005bf0:	40 00 2d a5 	call  40011284 <__errno>                       
40005bf4:	b0 10 3f ff 	mov  -1, %i0                                   
40005bf8:	82 10 20 09 	mov  9, %g1                                    
40005bfc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40005c00:	81 c7 e0 08 	ret                                            
40005c04:	81 e8 00 00 	restore                                        
                                                                      

4001c9cc <realloc>: void *realloc( void *ptr, size_t size ) {
4001c9cc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
                                                                      
  MSBUMP(realloc_calls, 1);                                           
4001c9d0:	3b 10 00 80 	sethi  %hi(0x40020000), %i5                    
4001c9d4:	ba 17 61 30 	or  %i5, 0x130, %i5	! 40020130 <rtems_malloc_statistics>
4001c9d8:	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())) {                     
4001c9dc:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
4001c9e0:	c2 00 63 b8 	ld  [ %g1 + 0x3b8 ], %g1	! 400207b8 <_System_state_Current>
)                                                                     
{                                                                     
  uintptr_t old_size;                                                 
  char    *new_area;                                                  
                                                                      
  MSBUMP(realloc_calls, 1);                                           
4001c9e4:	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())) {                     
4001c9e8:	80 a0 60 03 	cmp  %g1, 3                                    
4001c9ec:	02 80 00 2a 	be  4001ca94 <realloc+0xc8>                    
4001c9f0:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        
  }                                                                   
                                                                      
  /*                                                                  
   * Continue with realloc().                                         
   */                                                                 
  if ( !ptr )                                                         
4001c9f4:	80 a6 20 00 	cmp  %i0, 0                                    
4001c9f8:	02 80 00 46 	be  4001cb10 <realloc+0x144>                   
4001c9fc:	80 a6 60 00 	cmp  %i1, 0                                    
    return malloc( size );                                            
                                                                      
  if ( !size ) {                                                      
4001ca00:	02 80 00 39 	be  4001cae4 <realloc+0x118>                   <== NEVER TAKEN
4001ca04:	39 10 00 7d 	sethi  %hi(0x4001f400), %i4                    
    free( ptr );                                                      
    return (void *) 0;                                                
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
4001ca08:	d0 07 21 60 	ld  [ %i4 + 0x160 ], %o0	! 4001f560 <RTEMS_Malloc_Heap>
4001ca0c:	92 10 00 18 	mov  %i0, %o1                                  
4001ca10:	40 00 01 d6 	call  4001d168 <_Protected_heap_Get_block_size>
4001ca14:	94 07 bf fc 	add  %fp, -4, %o2                              
4001ca18:	80 8a 20 ff 	btst  0xff, %o0                                
4001ca1c:	02 80 00 37 	be  4001caf8 <realloc+0x12c>                   
4001ca20:	d0 07 21 60 	ld  [ %i4 + 0x160 ], %o0                       
  }                                                                   
                                                                      
  /*                                                                  
   *  Now resize it.                                                  
   */                                                                 
  if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
4001ca24:	92 10 00 18 	mov  %i0, %o1                                  
4001ca28:	40 00 01 de 	call  4001d1a0 <_Protected_heap_Resize_block>  
4001ca2c:	94 10 00 19 	mov  %i1, %o2                                  
4001ca30:	80 8a 20 ff 	btst  0xff, %o0                                
4001ca34:	02 80 00 04 	be  4001ca44 <realloc+0x78>                    
4001ca38:	01 00 00 00 	nop                                            
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
  free( ptr );                                                        
                                                                      
  return new_area;                                                    
                                                                      
}                                                                     
4001ca3c:	81 c7 e0 08 	ret                                            
4001ca40:	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 );                                          
4001ca44:	7f ff 9e cb 	call  40004570 <malloc>                        
4001ca48:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
4001ca4c:	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 );                                          
4001ca50:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
  MSBUMP(malloc_calls, (uint32_t) -1);   /* subtract off the malloc */
4001ca54:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
  if ( !new_area ) {                                                  
4001ca58:	80 a2 20 00 	cmp  %o0, 0                                    
4001ca5c:	02 80 00 17 	be  4001cab8 <realloc+0xec>                    
4001ca60:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
    return (void *) 0;                                                
  }                                                                   
                                                                      
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
4001ca64:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4001ca68:	80 a6 40 01 	cmp  %i1, %g1                                  
4001ca6c:	18 80 00 15 	bgu  4001cac0 <realloc+0xf4>                   <== ALWAYS TAKEN
4001ca70:	94 10 00 19 	mov  %i1, %o2                                  
4001ca74:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001ca78:	7f ff d2 03 	call  40011284 <memcpy>                        <== NOT EXECUTED
4001ca7c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
  free( ptr );                                                        
4001ca80:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001ca84:	7f ff 9d e1 	call  40004208 <free>                          <== NOT EXECUTED
4001ca88:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
4001ca8c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ca90:	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 )                      
4001ca94:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4001ca98:	c2 00 62 b0 	ld  [ %g1 + 0x2b0 ], %g1	! 400202b0 <_Thread_Dispatch_disable_level>
4001ca9c:	80 a0 60 00 	cmp  %g1, 0                                    
4001caa0:	12 80 00 06 	bne  4001cab8 <realloc+0xec>                   <== NEVER TAKEN
4001caa4:	03 10 00 81 	sethi  %hi(0x40020400), %g1                    
                                                                      
  if (_System_state_Is_up(_System_state_Get())) {                     
    if (_Thread_Dispatch_in_critical_section())                       
      return (void *) 0;                                              
                                                                      
    if (_ISR_Nest_level > 0)                                          
4001caa8:	c2 00 63 c8 	ld  [ %g1 + 0x3c8 ], %g1	! 400207c8 <_Per_CPU_Information+0x8>
4001caac:	80 a0 60 00 	cmp  %g1, 0                                    
4001cab0:	02 bf ff d2 	be  4001c9f8 <realloc+0x2c>                    <== ALWAYS TAKEN
4001cab4:	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;                                              
4001cab8:	81 c7 e0 08 	ret                                            
4001cabc:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      
  if ( !new_area ) {                                                  
    return (void *) 0;                                                
  }                                                                   
                                                                      
  memcpy( new_area, ptr, (size < old_size) ? size : old_size );       
4001cac0:	92 10 00 18 	mov  %i0, %o1                                  
4001cac4:	94 10 00 01 	mov  %g1, %o2                                  
4001cac8:	7f ff d1 ef 	call  40011284 <memcpy>                        
4001cacc:	90 10 00 1c 	mov  %i4, %o0                                  
  free( ptr );                                                        
4001cad0:	90 10 00 18 	mov  %i0, %o0                                  
4001cad4:	7f ff 9d cd 	call  40004208 <free>                          
4001cad8:	b0 10 00 1c 	mov  %i4, %i0                                  
4001cadc:	81 c7 e0 08 	ret                                            
4001cae0:	81 e8 00 00 	restore                                        
   */                                                                 
  if ( !ptr )                                                         
    return malloc( size );                                            
                                                                      
  if ( !size ) {                                                      
    free( ptr );                                                      
4001cae4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001cae8:	7f ff 9d c8 	call  40004208 <free>                          <== NOT EXECUTED
4001caec:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4001caf0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001caf4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    return (void *) 0;                                                
  }                                                                   
                                                                      
  if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
    errno = EINVAL;                                                   
4001caf8:	7f ff cf 92 	call  40010940 <__errno>                       
4001cafc:	b0 10 20 00 	clr  %i0                                       
4001cb00:	82 10 20 16 	mov  0x16, %g1                                 
4001cb04:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001cb08:	81 c7 e0 08 	ret                                            
4001cb0c:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   * Continue with realloc().                                         
   */                                                                 
  if ( !ptr )                                                         
    return malloc( size );                                            
4001cb10:	7f ff 9e 98 	call  40004570 <malloc>                        
4001cb14:	91 e8 00 19 	restore  %g0, %i1, %o0                         
                                                                      

40008af4 <rtems_aio_enqueue>: * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) {
40008af4:	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);             
40008af8:	39 10 00 68 	sethi  %hi(0x4001a000), %i4                    
40008afc:	40 00 02 7b 	call  400094e8 <pthread_mutex_lock>            
40008b00:	90 17 23 cc 	or  %i4, 0x3cc, %o0	! 4001a3cc <aio_request_queue>
  if (result != 0) {                                                  
40008b04:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40008b08:	12 80 00 31 	bne  40008bcc <rtems_aio_enqueue+0xd8>         <== NEVER TAKEN
40008b0c:	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);            
40008b10:	40 00 04 b6 	call  40009de8 <pthread_self>                  
40008b14:	b2 17 23 cc 	or  %i4, 0x3cc, %i1                            
40008b18:	92 07 bf e0 	add  %fp, -32, %o1                             
40008b1c:	40 00 03 a8 	call  400099bc <pthread_getschedparam>         
40008b20:	94 07 bf e4 	add  %fp, -28, %o2                             
                                                                      
  req->caller_thread = pthread_self ();                               
40008b24:	40 00 04 b1 	call  40009de8 <pthread_self>                  
40008b28:	01 00 00 00 	nop                                            
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
40008b2c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  req->policy = policy;                                               
40008b30:	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;    
40008b34:	c4 00 60 18 	ld  [ %g1 + 0x18 ], %g2                        
  req->policy = policy;                                               
40008b38:	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;    
40008b3c:	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 ();                               
40008b40:	d0 26 20 10 	st  %o0, [ %i0 + 0x10 ]                        
  req->priority = param.sched_priority - req->aiocbp->aio_reqprio;    
40008b44:	84 20 c0 02 	sub  %g3, %g2, %g2                             
40008b48:	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) &&                        
40008b4c:	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;                              
40008b50:	86 10 20 77 	mov  0x77, %g3                                 
  req->aiocbp->return_value = 0;                                      
40008b54:	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;                              
40008b58:	c6 20 60 34 	st  %g3, [ %g1 + 0x34 ]                        
  req->aiocbp->return_value = 0;                                      
                                                                      
  if ((aio_request_queue.idle_threads == 0) &&                        
40008b5c:	80 a0 a0 00 	cmp  %g2, 0                                    
40008b60:	12 80 00 06 	bne  40008b78 <rtems_aio_enqueue+0x84>         <== NEVER TAKEN
40008b64:	d2 00 40 00 	ld  [ %g1 ], %o1                               
40008b68:	c4 06 60 64 	ld  [ %i1 + 0x64 ], %g2                        
40008b6c:	80 a0 a0 04 	cmp  %g2, 4                                    
40008b70:	24 80 00 1b 	ble,a   40008bdc <rtems_aio_enqueue+0xe8>      
40008b74:	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,     
40008b78:	94 10 20 00 	clr  %o2                                       
40008b7c:	11 10 00 69 	sethi  %hi(0x4001a400), %o0                    
40008b80:	7f ff ff 78 	call  40008960 <rtems_aio_search_fd>           
40008b84:	90 12 20 14 	or  %o0, 0x14, %o0	! 4001a414 <aio_request_queue+0x48>
				     req->aiocbp->aio_fildes, 0);                                 
      if (r_chain != NULL)                                            
40008b88:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40008b8c:	22 80 00 31 	be,a   40008c50 <rtems_aio_enqueue+0x15c>      
40008b90:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
	{                                                                    
	  pthread_mutex_lock (&r_chain->mutex);                              
40008b94:	b2 06 a0 1c 	add  %i2, 0x1c, %i1                            
40008b98:	40 00 02 54 	call  400094e8 <pthread_mutex_lock>            
40008b9c:	90 10 00 19 	mov  %i1, %o0                                  
	  rtems_aio_insert_prio (&r_chain->perfd, req);                      
40008ba0:	90 06 a0 08 	add  %i2, 8, %o0                               
40008ba4:	7f ff ff 12 	call  400087ec <rtems_aio_insert_prio>         
40008ba8:	92 10 00 18 	mov  %i0, %o1                                  
	  pthread_cond_signal (&r_chain->cond);                              
40008bac:	40 00 01 2c 	call  4000905c <pthread_cond_signal>           
40008bb0:	90 06 a0 20 	add  %i2, 0x20, %o0                            
	  pthread_mutex_unlock (&r_chain->mutex);                            
40008bb4:	40 00 02 6d 	call  40009568 <pthread_mutex_unlock>          
40008bb8:	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);                    
40008bbc:	40 00 02 6b 	call  40009568 <pthread_mutex_unlock>          
40008bc0:	90 17 23 cc 	or  %i4, 0x3cc, %o0                            
  return 0;                                                           
}                                                                     
40008bc4:	81 c7 e0 08 	ret                                            
40008bc8:	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);                                                       
40008bcc:	7f ff ee 44 	call  400044dc <free>                          <== NOT EXECUTED
40008bd0:	b0 10 00 1b 	mov  %i3, %i0                                  <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
  pthread_mutex_unlock (&aio_request_queue.mutex);                    
  return 0;                                                           
}                                                                     
40008bd4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40008bd8:	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);
40008bdc:	7f ff ff 61 	call  40008960 <rtems_aio_search_fd>           
40008be0:	94 10 20 01 	mov  1, %o2                                    
                                                                      
      if (r_chain->new_fd == 1) {                                     
40008be4:	c2 02 20 18 	ld  [ %o0 + 0x18 ], %g1                        
40008be8:	80 a0 60 01 	cmp  %g1, 1                                    
40008bec:	12 bf ff ea 	bne  40008b94 <rtems_aio_enqueue+0xa0>         
40008bf0:	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);                    
40008bf4:	90 02 20 08 	add  %o0, 8, %o0                               
40008bf8:	40 00 09 44 	call  4000b108 <_Chain_Insert>                 
40008bfc:	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);                          
40008c00:	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;                                                 
40008c04:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            
	pthread_mutex_init (&r_chain->mutex, NULL);                          
40008c08:	40 00 01 df 	call  40009384 <pthread_mutex_init>            
40008c0c:	90 06 a0 1c 	add  %i2, 0x1c, %o0                            
	pthread_cond_init (&r_chain->cond, NULL);                            
40008c10:	92 10 20 00 	clr  %o1                                       
40008c14:	40 00 00 e3 	call  40008fa0 <pthread_cond_init>             
40008c18:	90 06 a0 20 	add  %i2, 0x20, %o0                            
	                                                                     
	AIO_printf ("New thread \n");                                        
	result = pthread_create (&thid, &aio_request_queue.attr,             
40008c1c:	90 07 bf dc 	add  %fp, -36, %o0                             
40008c20:	92 06 60 08 	add  %i1, 8, %o1                               
40008c24:	96 10 00 1a 	mov  %i2, %o3                                  
40008c28:	15 10 00 21 	sethi  %hi(0x40008400), %o2                    
40008c2c:	40 00 02 c4 	call  4000973c <pthread_create>                
40008c30:	94 12 a1 40 	or  %o2, 0x140, %o2	! 40008540 <rtems_aio_handle>
				 rtems_aio_handle, (void *) r_chain);                             
	if (result != 0) {                                                   
40008c34:	82 92 20 00 	orcc  %o0, 0, %g1                              
40008c38:	12 80 00 25 	bne  40008ccc <rtems_aio_enqueue+0x1d8>        <== NEVER TAKEN
40008c3c:	90 10 00 19 	mov  %i1, %o0                                  
	  pthread_mutex_unlock (&aio_request_queue.mutex);                   
	  return result;                                                     
	}                                                                    
	++aio_request_queue.active_threads;                                  
40008c40:	c2 06 60 64 	ld  [ %i1 + 0x64 ], %g1                        
40008c44:	82 00 60 01 	inc  %g1                                       
40008c48:	10 bf ff dd 	b  40008bbc <rtems_aio_enqueue+0xc8>           
40008c4c:	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);   
40008c50:	11 10 00 69 	sethi  %hi(0x4001a400), %o0                    
40008c54:	d2 00 40 00 	ld  [ %g1 ], %o1                               
40008c58:	90 12 20 20 	or  %o0, 0x20, %o0                             
40008c5c:	7f ff ff 41 	call  40008960 <rtems_aio_search_fd>           
40008c60:	94 10 20 01 	mov  1, %o2                                    
                                                                      
	if (r_chain->new_fd == 1) {                                          
40008c64:	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);   
40008c68:	b4 10 00 08 	mov  %o0, %i2                                  
40008c6c:	92 10 00 18 	mov  %i0, %o1                                  
                                                                      
	if (r_chain->new_fd == 1) {                                          
40008c70:	80 a0 60 01 	cmp  %g1, 1                                    
40008c74:	02 80 00 0b 	be  40008ca0 <rtems_aio_enqueue+0x1ac>         
40008c78:	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);                      
40008c7c:	7f ff fe dc 	call  400087ec <rtems_aio_insert_prio>         
40008c80:	01 00 00 00 	nop                                            
	if (aio_request_queue.idle_threads > 0)                              
40008c84:	c2 06 60 68 	ld  [ %i1 + 0x68 ], %g1                        
40008c88:	80 a0 60 00 	cmp  %g1, 0                                    
40008c8c:	04 bf ff cc 	ble  40008bbc <rtems_aio_enqueue+0xc8>         <== ALWAYS TAKEN
40008c90:	01 00 00 00 	nop                                            
	  pthread_cond_signal (&aio_request_queue.new_req);                  
40008c94:	40 00 00 f2 	call  4000905c <pthread_cond_signal>           <== NOT EXECUTED
40008c98:	90 06 60 04 	add  %i1, 4, %o0                               <== NOT EXECUTED
40008c9c:	30 bf ff c8 	b,a   40008bbc <rtems_aio_enqueue+0xc8>        <== NOT EXECUTED
40008ca0:	40 00 09 1a 	call  4000b108 <_Chain_Insert>                 
40008ca4:	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);                        
40008ca8:	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;                                               
40008cac:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            
	  pthread_mutex_init (&r_chain->mutex, NULL);                        
40008cb0:	40 00 01 b5 	call  40009384 <pthread_mutex_init>            
40008cb4:	92 10 20 00 	clr  %o1                                       
	  pthread_cond_init (&r_chain->cond, NULL);                          
40008cb8:	90 06 a0 20 	add  %i2, 0x20, %o0                            
40008cbc:	40 00 00 b9 	call  40008fa0 <pthread_cond_init>             
40008cc0:	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)                              
40008cc4:	10 bf ff f1 	b  40008c88 <rtems_aio_enqueue+0x194>          
40008cc8:	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);                   
40008ccc:	40 00 02 27 	call  40009568 <pthread_mutex_unlock>          <== NOT EXECUTED
40008cd0:	b6 10 00 01 	mov  %g1, %i3                                  <== NOT EXECUTED
40008cd4:	30 bf ff bc 	b,a   40008bc4 <rtems_aio_enqueue+0xd0>        <== NOT EXECUTED
                                                                      

40008540 <rtems_aio_handle>: * NULL - if error */ static void * rtems_aio_handle (void *arg) {
40008540:	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);                  
40008544:	35 10 00 68 	sethi  %hi(0x4001a000), %i2                    
40008548:	b6 06 20 1c 	add  %i0, 0x1c, %i3                            
4000854c:	b4 16 a3 cc 	or  %i2, 0x3cc, %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,                   
40008550:	a0 10 00 1a 	mov  %i2, %l0                                  
40008554:	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)) {        
40008558:	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 &&                            
4000855c:	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);                    
40008560:	40 00 03 e2 	call  400094e8 <pthread_mutex_lock>            
40008564:	90 10 00 1b 	mov  %i3, %o0                                  
    if (result != 0)                                                  
40008568:	80 a2 20 00 	cmp  %o0, 0                                    
4000856c:	12 80 00 2b 	bne  40008618 <rtems_aio_handle+0xd8>          <== NEVER TAKEN
40008570:	01 00 00 00 	nop                                            
40008574:	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 );                            
40008578:	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)) {                              
4000857c:	80 a7 40 01 	cmp  %i5, %g1                                  
40008580:	02 80 00 41 	be  40008684 <rtems_aio_handle+0x144>          
40008584:	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);        
40008588:	40 00 06 18 	call  40009de8 <pthread_self>                  
4000858c:	01 00 00 00 	nop                                            
40008590:	92 07 bf d8 	add  %fp, -40, %o1                             
40008594:	40 00 05 0a 	call  400099bc <pthread_getschedparam>         
40008598:	94 07 bf e4 	add  %fp, -28, %o2                             
      param.sched_priority = req->priority;                           
4000859c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
      pthread_setschedparam (pthread_self(), req->policy, ¶m);    
400085a0:	40 00 06 12 	call  40009de8 <pthread_self>                  
400085a4:	c2 27 bf e4 	st  %g1, [ %fp + -28 ]                         
400085a8:	d2 07 60 08 	ld  [ %i5 + 8 ], %o1                           
400085ac:	40 00 06 13 	call  40009df8 <pthread_setschedparam>         
400085b0:	94 07 bf e4 	add  %fp, -28, %o2                             
400085b4:	40 00 0a bc 	call  4000b0a4 <_Chain_Extract>                
400085b8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      rtems_chain_extract (node);                                     
                                                                      
      pthread_mutex_unlock (&r_chain->mutex);                         
400085bc:	40 00 03 eb 	call  40009568 <pthread_mutex_unlock>          
400085c0:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
      switch (req->aiocbp->aio_lio_opcode) {                          
400085c4:	f8 07 60 14 	ld  [ %i5 + 0x14 ], %i4                        
400085c8:	c2 07 20 30 	ld  [ %i4 + 0x30 ], %g1                        
400085cc:	80 a0 60 02 	cmp  %g1, 2                                    
400085d0:	22 80 00 25 	be,a   40008664 <rtems_aio_handle+0x124>       
400085d4:	c4 1f 20 08 	ldd  [ %i4 + 8 ], %g2                          
400085d8:	80 a0 60 03 	cmp  %g1, 3                                    
400085dc:	02 80 00 1e 	be  40008654 <rtems_aio_handle+0x114>          <== NEVER TAKEN
400085e0:	01 00 00 00 	nop                                            
400085e4:	80 a0 60 01 	cmp  %g1, 1                                    
400085e8:	22 80 00 0e 	be,a   40008620 <rtems_aio_handle+0xe0>        <== ALWAYS TAKEN
400085ec:	c4 1f 20 08 	ldd  [ %i4 + 8 ], %g2                          
                                                                      
      default:                                                        
        result = -1;                                                  
      }                                                               
      if (result == -1) {                                             
        req->aiocbp->return_value = -1;                               
400085f0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
	req->aiocbp->error_code = errno;                                     
400085f4:	40 00 29 13 	call  40012a40 <__errno>                       <== NOT EXECUTED
400085f8:	c2 27 20 38 	st  %g1, [ %i4 + 0x38 ]                        <== NOT EXECUTED
400085fc:	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);                    
40008600:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40008604:	40 00 03 b9 	call  400094e8 <pthread_mutex_lock>            <== NOT EXECUTED
40008608:	c2 27 20 34 	st  %g1, [ %i4 + 0x34 ]                        <== NOT EXECUTED
    if (result != 0)                                                  
4000860c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40008610:	22 bf ff da 	be,a   40008578 <rtems_aio_handle+0x38>        <== NOT EXECUTED
40008614:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  AIO_printf ("Thread finished\n");                                   
  return NULL;                                                        
}                                                                     
40008618:	81 c7 e0 08 	ret                                            
4000861c:	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,                      
40008620:	d0 07 00 00 	ld  [ %i4 ], %o0                               
40008624:	d2 07 20 10 	ld  [ %i4 + 0x10 ], %o1                        
40008628:	d4 07 20 14 	ld  [ %i4 + 0x14 ], %o2                        
4000862c:	96 10 00 02 	mov  %g2, %o3                                  
40008630:	40 00 2b f0 	call  400135f0 <pread>                         
40008634:	98 10 00 03 	mov  %g3, %o4                                  
      	break;                                                         
                                                                      
      default:                                                        
        result = -1;                                                  
      }                                                               
      if (result == -1) {                                             
40008638:	80 a2 3f ff 	cmp  %o0, -1                                   
4000863c:	22 bf ff ed 	be,a   400085f0 <rtems_aio_handle+0xb0>        <== NEVER TAKEN
40008640:	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;                           
40008644:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
40008648:	d0 20 60 38 	st  %o0, [ %g1 + 0x38 ]                        
        req->aiocbp->error_code = 0;                                  
4000864c:	10 bf ff c5 	b  40008560 <rtems_aio_handle+0x20>            
40008650:	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);                      
40008654:	40 00 1b 79 	call  4000f438 <fsync>                         <== NOT EXECUTED
40008658:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
      	break;                                                         
4000865c:	10 bf ff f8 	b  4000863c <rtems_aio_handle+0xfc>            <== NOT EXECUTED
40008660:	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,                     
40008664:	d0 07 00 00 	ld  [ %i4 ], %o0                               
40008668:	d2 07 20 10 	ld  [ %i4 + 0x10 ], %o1                        
4000866c:	d4 07 20 14 	ld  [ %i4 + 0x14 ], %o2                        
40008670:	96 10 00 02 	mov  %g2, %o3                                  
40008674:	40 00 2c 1d 	call  400136e8 <pwrite>                        
40008678:	98 10 00 03 	mov  %g3, %o4                                  
                         (void *) req->aiocbp->aio_buf,               
                         req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
        break;                                                        
4000867c:	10 bf ff f0 	b  4000863c <rtems_aio_handle+0xfc>            
40008680:	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);                         
40008684:	40 00 03 b9 	call  40009568 <pthread_mutex_unlock>          
40008688:	90 10 00 1b 	mov  %i3, %o0                                  
      pthread_mutex_lock (&aio_request_queue.mutex);                  
4000868c:	40 00 03 97 	call  400094e8 <pthread_mutex_lock>            
40008690:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
      if (rtems_chain_is_empty (chain))                               
40008694:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40008698:	80 a7 40 01 	cmp  %i5, %g1                                  
4000869c:	02 80 00 05 	be  400086b0 <rtems_aio_handle+0x170>          <== ALWAYS TAKEN
400086a0:	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);                
400086a4:	40 00 03 b1 	call  40009568 <pthread_mutex_unlock>          
400086a8:	90 10 00 1a 	mov  %i2, %o0                                  
400086ac:	30 bf ff ad 	b,a   40008560 <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);                          
400086b0:	40 00 01 d3 	call  40008dfc <clock_gettime>                 
400086b4:	90 10 20 01 	mov  1, %o0                                    
	  timeout.tv_sec += 3;                                               
400086b8:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
	  timeout.tv_nsec = 0;                                               
400086bc:	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;                                               
400086c0:	82 00 60 03 	add  %g1, 3, %g1                               
	  timeout.tv_nsec = 0;                                               
	  result = pthread_cond_timedwait (&r_chain->cond,                   
400086c4:	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;                                               
400086c8:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]                         
	  timeout.tv_nsec = 0;                                               
	  result = pthread_cond_timedwait (&r_chain->cond,                   
400086cc:	90 10 00 1d 	mov  %i5, %o0                                  
400086d0:	92 10 00 10 	mov  %l0, %o1                                  
400086d4:	40 00 02 7e 	call  400090cc <pthread_cond_timedwait>        
400086d8:	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) {                                         
400086dc:	80 a2 20 74 	cmp  %o0, 0x74                                 
400086e0:	12 bf ff f1 	bne  400086a4 <rtems_aio_handle+0x164>         <== NEVER TAKEN
400086e4:	01 00 00 00 	nop                                            
400086e8:	40 00 0a 6f 	call  4000b0a4 <_Chain_Extract>                
400086ec:	90 10 00 18 	mov  %i0, %o0                                  
	    rtems_chain_extract (&r_chain->next_fd);                         
	    pthread_mutex_destroy (&r_chain->mutex);                         
400086f0:	40 00 02 d2 	call  40009238 <pthread_mutex_destroy>         
400086f4:	90 10 00 1b 	mov  %i3, %o0                                  
	    pthread_cond_destroy (&r_chain->cond);                           
400086f8:	40 00 01 f4 	call  40008ec8 <pthread_cond_destroy>          
400086fc:	90 10 00 1d 	mov  %i5, %o0                                  
	    free (r_chain);                                                  
40008700:	7f ff ef 77 	call  400044dc <free>                          
40008704:	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;                    
40008708:	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)) {        
4000870c:	80 a6 00 12 	cmp  %i0, %l2                                  
40008710:	22 80 00 1d 	be,a   40008784 <rtems_aio_handle+0x244>       
40008714:	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;                                
40008718:	c4 04 60 68 	ld  [ %l1 + 0x68 ], %g2                        
	    ++aio_request_queue.active_threads;                              
4000871c:	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;                                
40008720:	84 00 bf ff 	add  %g2, -1, %g2                              
	    ++aio_request_queue.active_threads;                              
40008724:	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;                                
40008728:	c4 24 60 68 	st  %g2, [ %l1 + 0x68 ]                        
	    ++aio_request_queue.active_threads;                              
4000872c:	c2 24 60 64 	st  %g1, [ %l1 + 0x64 ]                        
40008730:	40 00 0a 5d 	call  4000b0a4 <_Chain_Extract>                
40008734:	90 10 00 18 	mov  %i0, %o0                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
40008738:	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 &&                            
4000873c:	c6 06 20 14 	ld  [ %i0 + 0x14 ], %g3                        
40008740:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
40008744:	80 a0 c0 02 	cmp  %g3, %g2                                  
40008748:	14 80 00 08 	bg  40008768 <rtems_aio_handle+0x228>          <== ALWAYS TAKEN
4000874c:	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 );                              
40008750:	10 80 00 09 	b  40008774 <rtems_aio_handle+0x234>           <== NOT EXECUTED
40008754:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           <== NOT EXECUTED
40008758:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
4000875c:	80 a0 80 03 	cmp  %g2, %g3                                  
40008760:	16 80 00 04 	bge  40008770 <rtems_aio_handle+0x230>         
40008764:	80 a0 40 19 	cmp  %g1, %i1                                  
40008768:	32 bf ff fc 	bne,a   40008758 <rtems_aio_handle+0x218>      <== ALWAYS TAKEN
4000876c:	c2 00 40 00 	ld  [ %g1 ], %g1                               
40008770:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           
40008774:	92 10 00 18 	mov  %i0, %o1                                  
40008778:	40 00 0a 64 	call  4000b108 <_Chain_Insert>                 
4000877c:	b6 06 20 1c 	add  %i0, 0x1c, %i3                            
40008780:	30 bf ff c9 	b,a   400086a4 <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;                            
40008784:	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;                              
40008788:	84 00 a0 01 	inc  %g2                                       
	      --aio_request_queue.active_threads;                            
4000878c:	82 00 7f ff 	add  %g1, -1, %g1                              
	      clock_gettime (CLOCK_REALTIME, &timeout);                      
40008790:	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;                              
40008794:	c4 26 a0 68 	st  %g2, [ %i2 + 0x68 ]                        
	      --aio_request_queue.active_threads;                            
40008798:	c2 26 a0 64 	st  %g1, [ %i2 + 0x64 ]                        
	      clock_gettime (CLOCK_REALTIME, &timeout);                      
4000879c:	40 00 01 98 	call  40008dfc <clock_gettime>                 
400087a0:	90 10 20 01 	mov  1, %o0                                    
	      timeout.tv_sec += 3;                                           
400087a4:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
	      timeout.tv_nsec = 0;                                           
400087a8:	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;                                           
400087ac:	82 00 60 03 	add  %g1, 3, %g1                               
	      timeout.tv_nsec = 0;                                           
                                                                      
	      result = pthread_cond_timedwait (&aio_request_queue.new_req,   
400087b0:	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;                                           
400087b4:	c2 27 bf dc 	st  %g1, [ %fp + -36 ]                         
	      timeout.tv_nsec = 0;                                           
                                                                      
	      result = pthread_cond_timedwait (&aio_request_queue.new_req,   
400087b8:	92 10 00 1a 	mov  %i2, %o1                                  
400087bc:	40 00 02 44 	call  400090cc <pthread_cond_timedwait>        
400087c0:	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) {                                     
400087c4:	80 a2 20 74 	cmp  %o0, 0x74                                 
400087c8:	22 80 00 04 	be,a   400087d8 <rtems_aio_handle+0x298>       <== ALWAYS TAKEN
400087cc:	c2 06 a0 68 	ld  [ %i2 + 0x68 ], %g1                        
400087d0:	10 bf ff d2 	b  40008718 <rtems_aio_handle+0x1d8>           <== NOT EXECUTED
400087d4:	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);                    
400087d8:	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;                                   
400087dc:	82 00 7f ff 	add  %g1, -1, %g1                              
		pthread_mutex_unlock (&aio_request_queue.mutex);                    
400087e0:	40 00 03 62 	call  40009568 <pthread_mutex_unlock>          
400087e4:	c2 26 a0 68 	st  %g1, [ %i2 + 0x68 ]                        
400087e8:	30 bf ff 8c 	b,a   40008618 <rtems_aio_handle+0xd8>         
                                                                      

40008858 <rtems_aio_init>: * 0 - if initialization succeeded */ int rtems_aio_init (void) {
40008858:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int result = 0;                                                     
                                                                      
  result = pthread_attr_init (&aio_request_queue.attr);               
4000885c:	3b 10 00 68 	sethi  %hi(0x4001a000), %i5                    
40008860:	40 00 03 9c 	call  400096d0 <pthread_attr_init>             
40008864:	90 17 63 d4 	or  %i5, 0x3d4, %o0	! 4001a3d4 <aio_request_queue+0x8>
  if (result != 0)                                                    
40008868:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000886c:	12 80 00 23 	bne  400088f8 <rtems_aio_init+0xa0>            <== NEVER TAKEN
40008870:	90 17 63 d4 	or  %i5, 0x3d4, %o0                            
    return result;                                                    
                                                                      
  result =                                                            
40008874:	40 00 03 a3 	call  40009700 <pthread_attr_setdetachstate>   
40008878:	92 10 20 00 	clr  %o1                                       
    pthread_attr_setdetachstate (&aio_request_queue.attr,             
                                 PTHREAD_CREATE_DETACHED);            
  if (result != 0)                                                    
4000887c:	80 a2 20 00 	cmp  %o0, 0                                    
40008880:	12 80 00 20 	bne  40008900 <rtems_aio_init+0xa8>            <== NEVER TAKEN
40008884:	39 10 00 68 	sethi  %hi(0x4001a000), %i4                    
    pthread_attr_destroy (&aio_request_queue.attr);                   
                                                                      
                                                                      
  result = pthread_mutex_init (&aio_request_queue.mutex, NULL);       
40008888:	92 10 20 00 	clr  %o1                                       
4000888c:	40 00 02 be 	call  40009384 <pthread_mutex_init>            
40008890:	90 17 23 cc 	or  %i4, 0x3cc, %o0                            
  if (result != 0)                                                    
40008894:	80 a2 20 00 	cmp  %o0, 0                                    
40008898:	12 80 00 23 	bne  40008924 <rtems_aio_init+0xcc>            <== NEVER TAKEN
4000889c:	92 10 20 00 	clr  %o1                                       
    pthread_attr_destroy (&aio_request_queue.attr);                   
                                                                      
                                                                      
  result = pthread_cond_init (&aio_request_queue.new_req, NULL);      
400088a0:	11 10 00 68 	sethi  %hi(0x4001a000), %o0                    
400088a4:	40 00 01 bf 	call  40008fa0 <pthread_cond_init>             
400088a8:	90 12 23 d0 	or  %o0, 0x3d0, %o0	! 4001a3d0 <aio_request_queue+0x4>
  if (result != 0) {                                                  
400088ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400088b0:	12 80 00 26 	bne  40008948 <rtems_aio_init+0xf0>            <== NEVER TAKEN
400088b4:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
400088b8:	82 17 23 cc 	or  %i4, 0x3cc, %g1                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
400088bc:	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;                                                  
400088c0:	ba 00 60 4c 	add  %g1, 0x4c, %i5                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
400088c4:	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;                                                  
400088c8:	86 00 60 58 	add  %g1, 0x58, %g3                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
400088cc:	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;                                                  
400088d0:	fa 20 60 48 	st  %i5, [ %g1 + 0x48 ]                        
  head->previous = NULL;                                              
400088d4:	c0 20 60 4c 	clr  [ %g1 + 0x4c ]                            
  tail->previous = head;                                              
400088d8:	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;                                                  
400088dc:	c6 20 60 54 	st  %g3, [ %g1 + 0x54 ]                        
  head->previous = NULL;                                              
400088e0:	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;                               
400088e4:	c0 20 60 64 	clr  [ %g1 + 0x64 ]                            
  aio_request_queue.idle_threads = 0;                                 
400088e8:	c0 20 60 68 	clr  [ %g1 + 0x68 ]                            
  aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;              
400088ec:	05 00 00 2c 	sethi  %hi(0xb000), %g2                        
400088f0:	84 10 a0 0b 	or  %g2, 0xb, %g2	! b00b <PROM_START+0xb00b>   
400088f4:	c4 20 60 60 	st  %g2, [ %g1 + 0x60 ]                        
                                                                      
  return result;                                                      
}                                                                     
400088f8:	81 c7 e0 08 	ret                                            
400088fc:	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);                   
40008900:	40 00 03 68 	call  400096a0 <pthread_attr_destroy>          <== NOT EXECUTED
40008904:	90 17 63 d4 	or  %i5, 0x3d4, %o0                            <== NOT EXECUTED
                                                                      
                                                                      
  result = pthread_mutex_init (&aio_request_queue.mutex, NULL);       
40008908:	39 10 00 68 	sethi  %hi(0x4001a000), %i4                    <== NOT EXECUTED
4000890c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40008910:	40 00 02 9d 	call  40009384 <pthread_mutex_init>            <== NOT EXECUTED
40008914:	90 17 23 cc 	or  %i4, 0x3cc, %o0                            <== NOT EXECUTED
  if (result != 0)                                                    
40008918:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000891c:	02 bf ff e1 	be  400088a0 <rtems_aio_init+0x48>             <== NOT EXECUTED
40008920:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
    pthread_attr_destroy (&aio_request_queue.attr);                   
40008924:	40 00 03 5f 	call  400096a0 <pthread_attr_destroy>          <== NOT EXECUTED
40008928:	90 17 63 d4 	or  %i5, 0x3d4, %o0                            <== NOT EXECUTED
                                                                      
                                                                      
  result = pthread_cond_init (&aio_request_queue.new_req, NULL);      
4000892c:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40008930:	11 10 00 68 	sethi  %hi(0x4001a000), %o0                    <== NOT EXECUTED
40008934:	40 00 01 9b 	call  40008fa0 <pthread_cond_init>             <== NOT EXECUTED
40008938:	90 12 23 d0 	or  %o0, 0x3d0, %o0	! 4001a3d0 <aio_request_queue+0x4><== NOT EXECUTED
  if (result != 0) {                                                  
4000893c:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
40008940:	22 bf ff df 	be,a   400088bc <rtems_aio_init+0x64>          <== NOT EXECUTED
40008944:	82 17 23 cc 	or  %i4, 0x3cc, %g1                            <== NOT EXECUTED
    pthread_mutex_destroy (&aio_request_queue.mutex);                 
40008948:	40 00 02 3c 	call  40009238 <pthread_mutex_destroy>         <== NOT EXECUTED
4000894c:	90 17 23 cc 	or  %i4, 0x3cc, %o0                            <== NOT EXECUTED
    pthread_attr_destroy (&aio_request_queue.attr);                   
40008950:	40 00 03 54 	call  400096a0 <pthread_attr_destroy>          <== NOT EXECUTED
40008954:	90 17 63 d4 	or  %i5, 0x3d4, %o0                            <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40008958:	10 bf ff d9 	b  400088bc <rtems_aio_init+0x64>              <== NOT EXECUTED
4000895c:	82 17 23 cc 	or  %i4, 0x3cc, %g1                            <== NOT EXECUTED
                                                                      

400087ec <rtems_aio_insert_prio>:
400087ec:	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 );                            
400087f0:	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)) {                                 
400087f4:	80 a0 40 04 	cmp  %g1, %g4                                  
400087f8:	02 80 00 15 	be  4000884c <rtems_aio_insert_prio+0x60>      <== NEVER TAKEN
400087fc:	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 &&                         
40008800:	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;     
40008804:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        
                                                                      
    while (req->aiocbp->aio_reqprio > prio &&                         
40008808:	c6 00 e0 18 	ld  [ %g3 + 0x18 ], %g3                        
4000880c:	c4 00 a0 18 	ld  [ %g2 + 0x18 ], %g2                        
40008810:	80 a0 80 03 	cmp  %g2, %g3                                  
40008814:	26 80 00 07 	bl,a   40008830 <rtems_aio_insert_prio+0x44>   <== NEVER TAKEN
40008818:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
4000881c:	10 80 00 0b 	b  40008848 <rtems_aio_insert_prio+0x5c>       
40008820:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           
40008824:	22 80 00 09 	be,a   40008848 <rtems_aio_insert_prio+0x5c>   <== NOT EXECUTED
40008828:	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;                                              
4000882c:	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;       
40008830:	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 &&                         
40008834:	c4 00 a0 18 	ld  [ %g2 + 0x18 ], %g2                        <== NOT EXECUTED
40008838:	80 a0 80 03 	cmp  %g2, %g3                                  <== NOT EXECUTED
4000883c:	06 bf ff fa 	bl  40008824 <rtems_aio_insert_prio+0x38>      <== NOT EXECUTED
40008840:	80 a1 00 01 	cmp  %g4, %g1                                  <== NOT EXECUTED
40008844:	d0 00 60 04 	ld  [ %g1 + 4 ], %o0                           <== NOT EXECUTED
40008848:	92 10 00 0d 	mov  %o5, %o1                                  
4000884c:	82 13 c0 00 	mov  %o7, %g1                                  
40008850:	40 00 0a 2e 	call  4000b108 <_Chain_Insert>                 
40008854:	9e 10 40 00 	mov  %g1, %o7                                  
                                                                      

40008a34 <rtems_aio_remove_fd>: * Output parameters: * NONE */ void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain) {
40008a34:	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;                              
40008a38:	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 ));            
40008a3c:	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))                          
40008a40:	80 a7 40 18 	cmp  %i5, %i0                                  
40008a44:	02 80 00 0e 	be  40008a7c <rtems_aio_remove_fd+0x48>        <== NEVER TAKEN
40008a48:	b6 10 20 8c 	mov  0x8c, %i3                                 
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
40008a4c:	40 00 09 96 	call  4000b0a4 <_Chain_Extract>                
40008a50:	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;                            
40008a54:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
40008a58:	f8 07 40 00 	ld  [ %i5 ], %i4                               
      req->aiocbp->return_value = -1;                                 
40008a5c:	84 10 3f ff 	mov  -1, %g2                                   
      free (req);                                                     
40008a60:	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;                            
40008a64:	f6 20 60 34 	st  %i3, [ %g1 + 0x34 ]                        
      req->aiocbp->return_value = -1;                                 
      free (req);                                                     
40008a68:	7f ff ee 9d 	call  400044dc <free>                          
40008a6c:	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))                          
40008a70:	80 a7 00 18 	cmp  %i4, %i0                                  
40008a74:	12 bf ff f6 	bne  40008a4c <rtems_aio_remove_fd+0x18>       
40008a78:	ba 10 00 1c 	mov  %i4, %i5                                  
40008a7c:	81 c7 e0 08 	ret                                            
40008a80:	81 e8 00 00 	restore                                        
                                                                      

40008a84 <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) {
40008a84:	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;                    
40008a88:	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 );                            
40008a8c:	84 06 20 04 	add  %i0, 4, %g2                               
  if (rtems_chain_is_empty (chain))                                   
40008a90:	80 a7 40 02 	cmp  %i5, %g2                                  
40008a94:	12 80 00 06 	bne  40008aac <rtems_aio_remove_req+0x28>      
40008a98:	b0 10 20 02 	mov  2, %i0                                    
40008a9c:	30 80 00 12 	b,a   40008ae4 <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) {
40008aa0:	80 a0 80 1d 	cmp  %g2, %i5                                  <== NOT EXECUTED
40008aa4:	02 80 00 12 	be  40008aec <rtems_aio_remove_req+0x68>       <== NOT EXECUTED
40008aa8:	01 00 00 00 	nop                                            <== NOT EXECUTED
40008aac:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
40008ab0:	80 a0 40 19 	cmp  %g1, %i1                                  
40008ab4:	32 bf ff fb 	bne,a   40008aa0 <rtems_aio_remove_req+0x1c>   <== NEVER TAKEN
40008ab8:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== NOT EXECUTED
40008abc:	40 00 09 7a 	call  4000b0a4 <_Chain_Extract>                
40008ac0:	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;                        
40008ac4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
      current->aiocbp->return_value = -1;                             
40008ac8:	84 10 3f ff 	mov  -1, %g2                                   
40008acc:	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;                        
40008ad0:	84 10 20 8c 	mov  0x8c, %g2                                 
      current->aiocbp->return_value = -1;                             
      free (current);                                                 
40008ad4:	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;                        
40008ad8:	c4 20 60 34 	st  %g2, [ %g1 + 0x34 ]                        
      current->aiocbp->return_value = -1;                             
      free (current);                                                 
40008adc:	7f ff ee 80 	call  400044dc <free>                          
40008ae0:	b0 10 20 00 	clr  %i0                                       
    }                                                                 
                                                                      
  return AIO_CANCELED;                                                
}                                                                     
40008ae4:	81 c7 e0 08 	ret                                            
40008ae8:	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;                                           
40008aec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40008af0:	91 e8 20 01 	restore  %g0, 1, %o0                           <== NOT EXECUTED
                                                                      

4000fecc <rtems_assoc_local_by_remote_bitfield>: uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) {
4000fecc:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000fed0:	b8 10 20 20 	mov  0x20, %i4                                 
  uint32_t   b;                                                       
  uint32_t   local_value = 0;                                         
4000fed4:	b6 10 20 00 	clr  %i3                                       
                                                                      
  for (b = 1; b; b <<= 1) {                                           
4000fed8:	10 80 00 04 	b  4000fee8 <rtems_assoc_local_by_remote_bitfield+0x1c>
4000fedc:	ba 10 20 01 	mov  1, %i5                                    
4000fee0:	02 80 00 0c 	be  4000ff10 <rtems_assoc_local_by_remote_bitfield+0x44>
4000fee4:	bb 2f 60 01 	sll  %i5, 1, %i5                               
    if (b & remote_value)                                             
4000fee8:	80 8f 40 19 	btst  %i5, %i1                                 
4000feec:	22 bf ff fd 	be,a   4000fee0 <rtems_assoc_local_by_remote_bitfield+0x14>
4000fef0:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
      local_value |= rtems_assoc_local_by_remote(ap, b);              
4000fef4:	92 10 00 1d 	mov  %i5, %o1                                  
4000fef8:	7f ff f3 d4 	call  4000ce48 <rtems_assoc_local_by_remote>   
4000fefc:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  uint32_t   b;                                                       
  uint32_t   local_value = 0;                                         
                                                                      
  for (b = 1; b; b <<= 1) {                                           
4000ff00:	bb 2f 60 01 	sll  %i5, 1, %i5                               
4000ff04:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
4000ff08:	12 bf ff f8 	bne  4000fee8 <rtems_assoc_local_by_remote_bitfield+0x1c><== ALWAYS TAKEN
4000ff0c:	b6 16 c0 08 	or  %i3, %o0, %i3                              
    if (b & remote_value)                                             
      local_value |= rtems_assoc_local_by_remote(ap, b);              
  }                                                                   
                                                                      
  return local_value;                                                 
}                                                                     
4000ff10:	81 c7 e0 08 	ret                                            
4000ff14:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
                                                                      

4000cea8 <rtems_assoc_ptr_by_local>: const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) {
4000cea8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
4000ceac:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000ceb0:	80 a2 20 00 	cmp  %o0, 0                                    
4000ceb4:	02 80 00 1d 	be  4000cf28 <rtems_assoc_ptr_by_local+0x80>   
4000ceb8:	13 10 00 79 	sethi  %hi(0x4001e400), %o1                    
4000cebc:	40 00 12 3b 	call  400117a8 <strcmp>                        
4000cec0:	92 12 61 18 	or  %o1, 0x118, %o1	! 4001e518 <IMFS_memfile_handlers+0x30>
4000cec4:	80 a2 20 00 	cmp  %o0, 0                                    
4000cec8:	22 80 00 12 	be,a   4000cf10 <rtems_assoc_ptr_by_local+0x68>
4000cecc:	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;                                
4000ced0:	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)                               
4000ced4:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000ced8:	80 a0 40 19 	cmp  %g1, %i1                                  
4000cedc:	32 80 00 07 	bne,a   4000cef8 <rtems_assoc_ptr_by_local+0x50>
4000cee0:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
4000cee4:	30 80 00 13 	b,a   4000cf30 <rtems_assoc_ptr_by_local+0x88> 
4000cee8:	80 a0 40 19 	cmp  %g1, %i1                                  
4000ceec:	02 80 00 11 	be  4000cf30 <rtems_assoc_ptr_by_local+0x88>   
4000cef0:	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++)                                             
4000cef4:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
4000cef8:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000cefc:	80 a0 60 00 	cmp  %g1, 0                                    
4000cf00:	32 bf ff fa 	bne,a   4000cee8 <rtems_assoc_ptr_by_local+0x40>
4000cf04:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000cf08:	81 c7 e0 08 	ret                                            
4000cf0c:	91 e8 00 02 	restore  %g0, %g2, %o0                         
4000cf10:	80 a0 a0 00 	cmp  %g2, 0                                    
4000cf14:	02 80 00 07 	be  4000cf30 <rtems_assoc_ptr_by_local+0x88>   <== NEVER TAKEN
4000cf18:	82 06 20 0c 	add  %i0, 0xc, %g1                             
4000cf1c:	84 10 00 18 	mov  %i0, %g2                                  
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
4000cf20:	10 bf ff ed 	b  4000ced4 <rtems_assoc_ptr_by_local+0x2c>    
4000cf24:	b0 10 00 01 	mov  %g1, %i0                                  
  for ( ; ap->name; ap++)                                             
    if (ap->local_value == local_value)                               
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
4000cf28:	81 c7 e0 08 	ret                                            
4000cf2c:	91 e8 20 00 	restore  %g0, 0, %o0                           
4000cf30:	81 c7 e0 08 	ret                                            
4000cf34:	81 e8 00 00 	restore                                        
                                                                      

40004a68 <rtems_assoc_ptr_by_name>: const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) {
40004a68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
40004a6c:	fa 06 00 00 	ld  [ %i0 ], %i5                               
40004a70:	80 a7 60 00 	cmp  %i5, 0                                    
40004a74:	02 80 00 1e 	be  40004aec <rtems_assoc_ptr_by_name+0x84>    
40004a78:	90 10 00 1d 	mov  %i5, %o0                                  
40004a7c:	13 10 00 5c 	sethi  %hi(0x40017000), %o1                    
40004a80:	40 00 34 9e 	call  40011cf8 <strcmp>                        
40004a84:	92 12 62 30 	or  %o1, 0x230, %o1	! 40017230 <_rodata_start+0x780>
40004a88:	80 a2 20 00 	cmp  %o0, 0                                    
40004a8c:	22 80 00 10 	be,a   40004acc <rtems_assoc_ptr_by_name+0x64> 
40004a90:	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;                                
40004a94:	10 80 00 06 	b  40004aac <rtems_assoc_ptr_by_name+0x44>     
40004a98:	b8 10 20 00 	clr  %i4                                       
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
                                                                      
  for ( ; ap->name; ap++)                                             
40004a9c:	fa 06 00 00 	ld  [ %i0 ], %i5                               
40004aa0:	80 a7 60 00 	cmp  %i5, 0                                    
40004aa4:	02 80 00 10 	be  40004ae4 <rtems_assoc_ptr_by_name+0x7c>    
40004aa8:	01 00 00 00 	nop                                            
    if (strcmp(ap->name, name) == 0)                                  
40004aac:	90 10 00 1d 	mov  %i5, %o0                                  
40004ab0:	40 00 34 92 	call  40011cf8 <strcmp>                        
40004ab4:	92 10 00 19 	mov  %i1, %o1                                  
40004ab8:	80 a2 20 00 	cmp  %o0, 0                                    
40004abc:	32 bf ff f8 	bne,a   40004a9c <rtems_assoc_ptr_by_name+0x34>
40004ac0:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
	return ap;                                                           
                                                                      
  return default_ap;                                                  
}                                                                     
40004ac4:	81 c7 e0 08 	ret                                            
40004ac8:	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++)                                             
40004acc:	80 a7 60 00 	cmp  %i5, 0                                    
40004ad0:	02 bf ff fd 	be  40004ac4 <rtems_assoc_ptr_by_name+0x5c>    <== NEVER TAKEN
40004ad4:	82 06 20 0c 	add  %i0, 0xc, %g1                             
40004ad8:	b8 10 00 18 	mov  %i0, %i4                                  
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
40004adc:	10 bf ff f4 	b  40004aac <rtems_assoc_ptr_by_name+0x44>     
40004ae0:	b0 10 00 01 	mov  %g1, %i0                                  
                                                                      
  for ( ; ap->name; ap++)                                             
40004ae4:	81 c7 e0 08 	ret                                            
40004ae8:	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;                                
40004aec:	81 c7 e0 08 	ret                                            
40004af0:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4000cf38 <rtems_assoc_ptr_by_remote>: const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) {
4000cf38:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
4000cf3c:	d0 06 00 00 	ld  [ %i0 ], %o0                               
4000cf40:	80 a2 20 00 	cmp  %o0, 0                                    
4000cf44:	02 80 00 1d 	be  4000cfb8 <rtems_assoc_ptr_by_remote+0x80>  
4000cf48:	13 10 00 79 	sethi  %hi(0x4001e400), %o1                    
4000cf4c:	40 00 12 17 	call  400117a8 <strcmp>                        
4000cf50:	92 12 61 18 	or  %o1, 0x118, %o1	! 4001e518 <IMFS_memfile_handlers+0x30>
4000cf54:	80 a2 20 00 	cmp  %o0, 0                                    
4000cf58:	22 80 00 12 	be,a   4000cfa0 <rtems_assoc_ptr_by_remote+0x68>
4000cf5c:	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;                                
4000cf60:	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)                             
4000cf64:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
4000cf68:	80 a0 40 19 	cmp  %g1, %i1                                  
4000cf6c:	32 80 00 07 	bne,a   4000cf88 <rtems_assoc_ptr_by_remote+0x50>
4000cf70:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
4000cf74:	30 80 00 13 	b,a   4000cfc0 <rtems_assoc_ptr_by_remote+0x88>
4000cf78:	80 a0 40 19 	cmp  %g1, %i1                                  
4000cf7c:	02 80 00 11 	be  4000cfc0 <rtems_assoc_ptr_by_remote+0x88>  
4000cf80:	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++)                                             
4000cf84:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
4000cf88:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000cf8c:	80 a0 60 00 	cmp  %g1, 0                                    
4000cf90:	32 bf ff fa 	bne,a   4000cf78 <rtems_assoc_ptr_by_remote+0x40>
4000cf94:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
4000cf98:	81 c7 e0 08 	ret                                            
4000cf9c:	91 e8 00 02 	restore  %g0, %g2, %o0                         
4000cfa0:	80 a0 a0 00 	cmp  %g2, 0                                    
4000cfa4:	02 80 00 07 	be  4000cfc0 <rtems_assoc_ptr_by_remote+0x88>  <== NEVER TAKEN
4000cfa8:	82 06 20 0c 	add  %i0, 0xc, %g1                             
4000cfac:	84 10 00 18 	mov  %i0, %g2                                  
)                                                                     
{                                                                     
  const rtems_assoc_t *default_ap = 0;                                
                                                                      
  if (rtems_assoc_is_default(ap))                                     
    default_ap = ap++;                                                
4000cfb0:	10 bf ff ed 	b  4000cf64 <rtems_assoc_ptr_by_remote+0x2c>   
4000cfb4:	b0 10 00 01 	mov  %g1, %i0                                  
  for ( ; ap->name; ap++)                                             
    if (ap->remote_value == remote_value)                             
      return ap;                                                      
                                                                      
  return default_ap;                                                  
}                                                                     
4000cfb8:	81 c7 e0 08 	ret                                            
4000cfbc:	91 e8 20 00 	restore  %g0, 0, %o0                           
4000cfc0:	81 c7 e0 08 	ret                                            
4000cfc4:	81 e8 00 00 	restore                                        
                                                                      

40004b84 <rtems_assoc_remote_by_local_bitfield>: uint32_t rtems_assoc_remote_by_local_bitfield( const rtems_assoc_t *ap, uint32_t local_value ) {
40004b84:	9d e3 bf a0 	save  %sp, -96, %sp                            
40004b88:	b8 10 20 20 	mov  0x20, %i4                                 
  uint32_t   b;                                                       
  uint32_t   remote_value = 0;                                        
40004b8c:	b6 10 20 00 	clr  %i3                                       
                                                                      
  for (b = 1; b; b <<= 1)                                             
40004b90:	10 80 00 04 	b  40004ba0 <rtems_assoc_remote_by_local_bitfield+0x1c>
40004b94:	ba 10 20 01 	mov  1, %i5                                    
40004b98:	02 80 00 0c 	be  40004bc8 <rtems_assoc_remote_by_local_bitfield+0x44>
40004b9c:	bb 2f 60 01 	sll  %i5, 1, %i5                               
    if (b & local_value)                                              
40004ba0:	80 8f 40 19 	btst  %i5, %i1                                 
40004ba4:	22 bf ff fd 	be,a   40004b98 <rtems_assoc_remote_by_local_bitfield+0x14>
40004ba8:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
      remote_value |= rtems_assoc_remote_by_local(ap, b);             
40004bac:	92 10 00 1d 	mov  %i5, %o1                                  
40004bb0:	40 00 00 08 	call  40004bd0 <rtems_assoc_remote_by_local>   
40004bb4:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  uint32_t   b;                                                       
  uint32_t   remote_value = 0;                                        
                                                                      
  for (b = 1; b; b <<= 1)                                             
40004bb8:	bb 2f 60 01 	sll  %i5, 1, %i5                               
40004bbc:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
40004bc0:	12 bf ff f8 	bne  40004ba0 <rtems_assoc_remote_by_local_bitfield+0x1c><== ALWAYS TAKEN
40004bc4:	b6 16 c0 08 	or  %i3, %o0, %i3                              
    if (b & local_value)                                              
      remote_value |= rtems_assoc_remote_by_local(ap, b);             
                                                                      
  return remote_value;                                                
}                                                                     
40004bc8:	81 c7 e0 08 	ret                                            
40004bcc:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
                                                                      

4000e2bc <rtems_bdbuf_add_to_modified_list_after_access>: } } static void rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd) {
4000e2bc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)   
4000e2c0:	3b 10 00 71 	sethi  %hi(0x4001c400), %i5                    
4000e2c4:	ba 17 61 8c 	or  %i5, 0x18c, %i5	! 4001c58c <bdbuf_cache>   
4000e2c8:	c2 0f 60 30 	ldub  [ %i5 + 0x30 ], %g1                      
4000e2cc:	80 a0 60 00 	cmp  %g1, 0                                    
4000e2d0:	22 80 00 08 	be,a   4000e2f0 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== ALWAYS TAKEN
4000e2d4:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
4000e2d8:	c4 07 60 38 	ld  [ %i5 + 0x38 ], %g2                        <== NOT EXECUTED
4000e2dc:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        <== NOT EXECUTED
4000e2e0:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
4000e2e4:	02 80 00 2b 	be  4000e390 <rtems_bdbuf_add_to_modified_list_after_access+0xd4><== NOT EXECUTED
4000e2e8:	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                    
4000e2ec:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        <== NOT EXECUTED
4000e2f0:	80 a0 60 05 	cmp  %g1, 5                                    
4000e2f4:	22 80 00 16 	be,a   4000e34c <rtems_bdbuf_add_to_modified_list_after_access+0x90>
4000e2f8:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
4000e2fc:	80 a0 60 03 	cmp  %g1, 3                                    
4000e300:	02 80 00 13 	be  4000e34c <rtems_bdbuf_add_to_modified_list_after_access+0x90>
4000e304:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e308:	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;                              
4000e30c:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
4000e310:	c4 26 20 20 	st  %g2, [ %i0 + 0x20 ]                        
                                                                      
  the_node->next = tail;                                              
4000e314:	84 07 60 50 	add  %i5, 0x50, %g2                            
  tail->previous = the_node;                                          
4000e318:	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;                                              
4000e31c:	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)                                                    
4000e320:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
4000e324:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
4000e328:	80 a0 a0 00 	cmp  %g2, 0                                    
4000e32c:	12 80 00 15 	bne  4000e380 <rtems_bdbuf_add_to_modified_list_after_access+0xc4>
4000e330:	f0 20 40 00 	st  %i0, [ %g1 ]                               
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
  else if (rtems_bdbuf_has_buffer_waiters ())                         
4000e334:	c2 07 60 74 	ld  [ %i5 + 0x74 ], %g1                        
4000e338:	80 a0 60 00 	cmp  %g1, 0                                    
4000e33c:	12 80 00 13 	bne  4000e388 <rtems_bdbuf_add_to_modified_list_after_access+0xcc>
4000e340:	01 00 00 00 	nop                                            
4000e344:	81 c7 e0 08 	ret                                            
4000e348:	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;                    
4000e34c:	c2 00 63 e8 	ld  [ %g1 + 0x3e8 ], %g1                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000e350:	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;                    
4000e354:	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;                              
4000e358:	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;                                                  
4000e35c:	c4 26 20 20 	st  %g2, [ %i0 + 0x20 ]                        
                                                                      
  the_node->next = tail;                                              
4000e360:	84 07 60 50 	add  %i5, 0x50, %g2                            
  tail->previous = the_node;                                          
4000e364:	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;                                              
4000e368:	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)                                                    
4000e36c:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
4000e370:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
4000e374:	80 a0 a0 00 	cmp  %g2, 0                                    
4000e378:	02 bf ff ef 	be  4000e334 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
4000e37c:	f0 20 40 00 	st  %i0, [ %g1 ]                               
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
4000e380:	7f ff ff c0 	call  4000e280 <rtems_bdbuf_wake>              
4000e384:	91 ef 60 64 	restore  %i5, 0x64, %o0                        
  else if (rtems_bdbuf_has_buffer_waiters ())                         
    rtems_bdbuf_wake_swapper ();                                      
4000e388:	7f ff ff 23 	call  4000e014 <rtems_bdbuf_wake_swapper>      
4000e38c:	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 ();                                      
4000e390:	7f ff ff 1b 	call  4000dffc <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000e394:	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);
4000e398:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        <== NOT EXECUTED
4000e39c:	7f ff fe f5 	call  4000df70 <rtems_bdbuf_lock>              <== NOT EXECUTED
4000e3a0:	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,                          
4000e3a4:	d0 07 60 2c 	ld  [ %i5 + 0x2c ], %o0                        <== NOT EXECUTED
4000e3a8:	7f ff ff 0a 	call  4000dfd0 <rtems_bdbuf_unlock>            <== NOT EXECUTED
4000e3ac:	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 ();                                        
4000e3b0:	7f ff fe fd 	call  4000dfa4 <rtems_bdbuf_lock_cache>        <== NOT EXECUTED
4000e3b4:	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                    
4000e3b8:	10 bf ff ce 	b  4000e2f0 <rtems_bdbuf_add_to_modified_list_after_access+0x34><== NOT EXECUTED
4000e3bc:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        <== NOT EXECUTED
                                                                      

4000e0bc <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) {
4000e0bc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_mode        prev_mode;                                        
                                                                      
  /*                                                                  
   * Indicate we are waiting.                                         
   */                                                                 
  ++waiters->count;                                                   
4000e0c0:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000e0c4:	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 ();                      
4000e0c8:	7f ff ff e0 	call  4000e048 <rtems_bdbuf_disable_preemption>
4000e0cc:	c2 26 00 00 	st  %g1, [ %i0 ]                               
                                                                      
  /*                                                                  
   * Unlock the cache, wait, and lock the cache when we return.       
   */                                                                 
  rtems_bdbuf_unlock_cache ();                                        
4000e0d0:	7f ff ff cb 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000e0d4:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
4000e0d8:	d0 06 20 04 	ld  [ %i0 + 4 ], %o0                           
4000e0dc:	92 10 20 00 	clr  %o1                                       
4000e0e0:	7f ff ee 40 	call  400099e0 <rtems_semaphore_obtain>        
4000e0e4:	94 10 20 00 	clr  %o2                                       
                                                                      
  if (sc == RTEMS_TIMEOUT)                                            
4000e0e8:	80 a2 20 06 	cmp  %o0, 6                                    
4000e0ec:	02 80 00 0d 	be  4000e120 <rtems_bdbuf_anonymous_wait+0x64> <== NEVER TAKEN
4000e0f0:	80 a2 20 0d 	cmp  %o0, 0xd                                  
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_TO);              
                                                                      
  if (sc != RTEMS_UNSATISFIED)                                        
4000e0f4:	12 80 00 0d 	bne  4000e128 <rtems_bdbuf_anonymous_wait+0x6c><== NEVER TAKEN
4000e0f8:	01 00 00 00 	nop                                            
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);               
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000e0fc:	7f ff ff aa 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
4000e100:	01 00 00 00 	nop                                            
                                                                      
  rtems_bdbuf_restore_preemption (prev_mode);                         
4000e104:	7f ff ff df 	call  4000e080 <rtems_bdbuf_restore_preemption>
4000e108:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  --waiters->count;                                                   
4000e10c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000e110:	82 00 7f ff 	add  %g1, -1, %g1                              
4000e114:	c2 26 00 00 	st  %g1, [ %i0 ]                               
4000e118:	81 c7 e0 08 	ret                                            
4000e11c:	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);              
4000e120:	7f ff ff 8f 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e124:	90 10 20 03 	mov  3, %o0                                    <== NOT EXECUTED
                                                                      
  if (sc != RTEMS_UNSATISFIED)                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAIT_2);               
4000e128:	7f ff ff 8d 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e12c:	90 10 20 02 	mov  2, %o0                                    <== NOT EXECUTED
                                                                      

4000e3c0 <rtems_bdbuf_create_task.constprop.9>: return NULL; } static rtems_status_code rtems_bdbuf_create_task(
4000e3c0:	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 ?                  
4000e3c4:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
4000e3c8:	d4 00 63 f4 	ld  [ %g1 + 0x3f4 ], %o2	! 4001abf4 <rtems_bdbuf_configuration+0x1c>
    bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
4000e3cc:	80 a2 a0 00 	cmp  %o2, 0                                    
4000e3d0:	12 80 00 03 	bne  4000e3dc <rtems_bdbuf_create_task.constprop.9+0x1c><== ALWAYS TAKEN
4000e3d4:	92 10 00 19 	mov  %i1, %o1                                  
4000e3d8:	15 00 00 04 	sethi  %hi(0x1000), %o2                        <== NOT EXECUTED
                                                                      
  priority = priority != 0 ? priority : default_priority;             
4000e3dc:	80 a2 60 00 	cmp  %o1, 0                                    
4000e3e0:	22 80 00 02 	be,a   4000e3e8 <rtems_bdbuf_create_task.constprop.9+0x28><== NEVER TAKEN
4000e3e4:	92 10 20 0f 	mov  0xf, %o1                                  <== NOT EXECUTED
                                                                      
  sc = rtems_task_create (name,                                       
4000e3e8:	90 10 00 18 	mov  %i0, %o0                                  
4000e3ec:	96 10 24 00 	mov  0x400, %o3                                
4000e3f0:	98 10 20 00 	clr  %o4                                       
4000e3f4:	7f ff ee 0a 	call  40009c1c <rtems_task_create>             
4000e3f8:	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)                                         
4000e3fc:	80 a2 20 00 	cmp  %o0, 0                                    
4000e400:	02 80 00 04 	be  4000e410 <rtems_bdbuf_create_task.constprop.9+0x50><== ALWAYS TAKEN
4000e404:	b0 10 00 08 	mov  %o0, %i0                                  
    sc = rtems_task_start (*id, entry, arg);                          
                                                                      
  return sc;                                                          
}                                                                     
4000e408:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000e40c:	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);                          
4000e410:	f0 07 00 00 	ld  [ %i4 ], %i0                               
4000e414:	b2 10 00 1a 	mov  %i2, %i1                                  
4000e418:	7f ff ee 8c 	call  40009e48 <rtems_task_start>              
4000e41c:	95 e8 00 1b 	restore  %g0, %i3, %o2                         
                                                                      

4000e048 <rtems_bdbuf_disable_preemption>: --bd->group->users; } static rtems_mode rtems_bdbuf_disable_preemption (void) {
4000e048:	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);
4000e04c:	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;                                           
4000e050:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
4000e054:	92 10 21 00 	mov  0x100, %o1                                
4000e058:	40 00 12 4d 	call  4001298c <rtems_task_mode>               
4000e05c:	94 07 bf fc 	add  %fp, -4, %o2                              
  if (sc != RTEMS_SUCCESSFUL)                                         
4000e060:	80 a2 20 00 	cmp  %o0, 0                                    
4000e064:	12 80 00 04 	bne  4000e074 <rtems_bdbuf_disable_preemption+0x2c><== NEVER TAKEN
4000e068:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_DIS);                
                                                                      
  return prev_mode;                                                   
}                                                                     
4000e06c:	81 c7 e0 08 	ret                                            
4000e070:	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);                
4000e074:	7f ff ff ba 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e078:	90 10 20 05 	mov  5, %o0                                    <== NOT EXECUTED
                                                                      

4000e840 <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) {
4000e840:	9d e3 bf a0 	save  %sp, -96, %sp                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000e844:	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)                                               
4000e848:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000e84c:	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)                                               
4000e850:	80 a0 a0 00 	cmp  %g2, 0                                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000e854:	86 00 ff ff 	add  %g3, -1, %g3                              
4000e858:	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;                                                  
4000e85c:	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)                                               
4000e860:	02 80 00 05 	be  4000e874 <rtems_bdbuf_discard_buffer_after_access+0x34>
4000e864:	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);                   
4000e868:	31 10 00 71 	sethi  %hi(0x4001c400), %i0                    
4000e86c:	7f ff fe 85 	call  4000e280 <rtems_bdbuf_wake>              
4000e870:	91 ee 21 f0 	restore  %i0, 0x1f0, %o0                       
4000e874:	7f ff ff e6 	call  4000e80c <rtems_bdbuf_discard_buffer.part.4>
4000e878:	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)                                                    
4000e87c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4000e880:	80 a0 60 00 	cmp  %g1, 0                                    
4000e884:	32 bf ff fa 	bne,a   4000e86c <rtems_bdbuf_discard_buffer_after_access+0x2c><== NEVER TAKEN
4000e888:	31 10 00 71 	sethi  %hi(0x4001c400), %i0                    <== NOT EXECUTED
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
  else                                                                
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
4000e88c:	31 10 00 71 	sethi  %hi(0x4001c400), %i0                    
4000e890:	7f ff fe 7c 	call  4000e280 <rtems_bdbuf_wake>              
4000e894:	91 ee 22 00 	restore  %i0, 0x200, %o0                       
                                                                      

4000f71c <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) {
4000f71c:	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) +                  
4000f720:	83 2e a0 04 	sll  %i2, 4, %g1                               
4000f724:	82 00 60 20 	add  %g1, 0x20, %g1                            
4000f728:	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;                              
4000f72c:	03 10 00 3d 	sethi  %hi(0x4000f400), %g1                    
4000f730:	82 10 63 f0 	or  %g1, 0x3f0, %g1	! 4000f7f0 <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) +                  
4000f734:	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;                          
4000f738:	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;                               
4000f73c:	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;       
4000f740:	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;                              
4000f744:	c2 24 60 04 	st  %g1, [ %l1 + 4 ]                           
  req->io_task = rtems_task_self ();                                  
4000f748:	40 00 0c fd 	call  40012b3c <rtems_task_self>               
4000f74c:	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;                                  
4000f750:	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 ();                                  
4000f754:	d0 24 60 14 	st  %o0, [ %l1 + 0x14 ]                        
  req->bufnum = 0;                                                    
4000f758:	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;                                                  
4000f75c:	84 10 20 09 	mov  9, %g2                                    
4000f760:	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;                                          
4000f764:	f2 24 60 24 	st  %i1, [ %l1 + 0x24 ]                        
  req->bufs [0].block  = media_block;                                 
4000f768:	f8 24 60 18 	st  %i4, [ %l1 + 0x18 ]                        
  req->bufs [0].length = block_size;                                  
4000f76c:	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)                             
4000f770:	80 a6 a0 01 	cmp  %i2, 1                                    
4000f774:	08 80 00 1d 	bleu  4000f7e8 <rtems_bdbuf_execute_read_request+0xcc>
4000f778:	c2 24 60 20 	st  %g1, [ %l1 + 0x20 ]                        
4000f77c:	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;                                        
4000f780:	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;                                                  
4000f784:	10 80 00 0b 	b  4000f7b0 <rtems_bdbuf_execute_read_request+0x94>
4000f788:	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;                           
4000f78c:	d0 27 60 34 	st  %o0, [ %i5 + 0x34 ]                        
    req->bufs [transfer_index].block  = media_block;                  
4000f790:	f8 27 60 28 	st  %i4, [ %i5 + 0x28 ]                        
    req->bufs [transfer_index].length = block_size;                   
4000f794:	e0 27 60 2c 	st  %l0, [ %i5 + 0x2c ]                        
    req->bufs [transfer_index].buffer = bd->buffer;                   
4000f798:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
                                                                      
    if (rtems_bdbuf_tracer)                                           
      rtems_bdbuf_show_users ("read", bd);                            
                                                                      
    ++transfer_index;                                                 
4000f79c:	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;                   
4000f7a0:	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)                             
4000f7a4:	80 a6 c0 1a 	cmp  %i3, %i2                                  
4000f7a8:	02 80 00 09 	be  4000f7cc <rtems_bdbuf_execute_read_request+0xb0>
4000f7ac:	ba 07 60 10 	add  %i5, 0x10, %i5                            
  {                                                                   
    media_block += media_blocks_per_block;                            
4000f7b0:	b8 07 00 12 	add  %i4, %l2, %i4                             
                                                                      
    bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);     
4000f7b4:	90 10 00 18 	mov  %i0, %o0                                  
4000f7b8:	7f ff fd 50 	call  4000ecf8 <rtems_bdbuf_get_buffer_for_read_ahead>
4000f7bc:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
    if (bd == NULL)                                                   
4000f7c0:	80 a2 20 00 	cmp  %o0, 0                                    
4000f7c4:	32 bf ff f2 	bne,a   4000f78c <rtems_bdbuf_execute_read_request+0x70><== ALWAYS TAKEN
4000f7c8:	f2 22 20 20 	st  %i1, [ %o0 + 0x20 ]                        
      rtems_bdbuf_show_users ("read", bd);                            
                                                                      
    ++transfer_index;                                                 
  }                                                                   
                                                                      
  req->bufnum = transfer_index;                                       
4000f7cc:	f6 24 60 10 	st  %i3, [ %l1 + 0x10 ]                        
                                                                      
  return rtems_bdbuf_execute_transfer_request (dd, req, true);        
4000f7d0:	90 10 00 18 	mov  %i0, %o0                                  
4000f7d4:	92 10 00 11 	mov  %l1, %o1                                  
4000f7d8:	7f ff fd f5 	call  4000efac <rtems_bdbuf_execute_transfer_request>
4000f7dc:	94 10 20 01 	mov  1, %o2                                    
}                                                                     
4000f7e0:	81 c7 e0 08 	ret                                            
4000f7e4:	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;                                        
4000f7e8:	10 bf ff f9 	b  4000f7cc <rtems_bdbuf_execute_read_request+0xb0>
4000f7ec:	b6 10 20 01 	mov  1, %i3                                    
                                                                      

4000efac <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) {
4000efac:	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)                                                   
4000efb0:	80 a6 a0 00 	cmp  %i2, 0                                    
4000efb4:	12 80 00 6e 	bne  4000f16c <rtems_bdbuf_execute_transfer_request+0x1c0>
4000efb8:	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);                 
4000efbc:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
4000efc0:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
4000efc4:	94 10 00 19 	mov  %i1, %o2                                  
4000efc8:	13 30 06 10 	sethi  %hi(0xc0184000), %o1                    
4000efcc:	9f c0 40 00 	call  %g1                                      
4000efd0:	92 12 62 01 	or  %o1, 0x201, %o1	! c0184201 <LEON_REG+0x40184201>
                                                                      
  /* Wait for transfer request completion */                          
  rtems_bdbuf_wait_for_transient_event ();                            
4000efd4:	7f ff ff e8 	call  4000ef74 <rtems_bdbuf_wait_for_transient_event>
4000efd8:	01 00 00 00 	nop                                            
  sc = req->status;                                                   
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000efdc:	7f ff fb f2 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
4000efe0:	f0 06 60 0c 	ld  [ %i1 + 0xc ], %i0                         
                                                                      
  /* Statistics */                                                    
  if (req->req == RTEMS_BLKDEV_REQ_READ)                              
4000efe4:	c2 06 40 00 	ld  [ %i1 ], %g1                               
4000efe8:	80 a0 60 00 	cmp  %g1, 0                                    
4000efec:	12 80 00 47 	bne  4000f108 <rtems_bdbuf_execute_transfer_request+0x15c>
4000eff0:	c8 06 60 10 	ld  [ %i1 + 0x10 ], %g4                        
  {                                                                   
    dd->stats.read_blocks += req->bufnum;                             
4000eff4:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
    if (sc != RTEMS_SUCCESSFUL)                                       
4000eff8:	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;                             
4000effc:	82 00 40 04 	add  %g1, %g4, %g1                             
    if (sc != RTEMS_SUCCESSFUL)                                       
4000f000:	12 80 00 57 	bne  4000f15c <rtems_bdbuf_execute_transfer_request+0x1b0>
4000f004:	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)
4000f008:	80 a1 20 00 	cmp  %g4, 0                                    
4000f00c:	02 80 00 35 	be  4000f0e0 <rtems_bdbuf_execute_transfer_request+0x134><== NEVER TAKEN
4000f010:	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;                              
4000f014:	21 10 00 71 	sethi  %hi(0x4001c400), %l0                    
4000f018:	b8 10 00 19 	mov  %i1, %i4                                  
4000f01c:	a0 14 21 8c 	or  %l0, 0x18c, %l0                            
4000f020:	a8 10 20 00 	clr  %l4                                       
4000f024:	ba 10 20 00 	clr  %i5                                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000f028:	a6 10 20 01 	mov  1, %l3                                    
4000f02c:	a4 10 20 02 	mov  2, %l2                                    
                                                                      
  the_node->next = tail;                                              
4000f030:	10 80 00 16 	b  4000f088 <rtems_bdbuf_execute_transfer_request+0xdc>
4000f034:	a2 04 20 44 	add  %l0, 0x44, %l1                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000f038:	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)
4000f03c:	80 a6 20 00 	cmp  %i0, 0                                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000f040:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
4000f044:	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)
4000f048:	12 80 00 06 	bne  4000f060 <rtems_bdbuf_execute_transfer_request+0xb4>
4000f04c:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
4000f050:	c2 02 20 20 	ld  [ %o0 + 0x20 ], %g1                        
4000f054:	80 a0 60 09 	cmp  %g1, 9                                    
4000f058:	22 80 00 13 	be,a   4000f0a4 <rtems_bdbuf_execute_transfer_request+0xf8>
4000f05c:	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)                                               
4000f060:	80 a0 a0 00 	cmp  %g2, 0                                    
4000f064:	12 80 00 05 	bne  4000f078 <rtems_bdbuf_execute_transfer_request+0xcc>
4000f068:	e6 22 20 20 	st  %l3, [ %o0 + 0x20 ]                        
4000f06c:	7f ff fd e8 	call  4000e80c <rtems_bdbuf_discard_buffer.part.4>
4000f070:	01 00 00 00 	nop                                            
4000f074:	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)
4000f078:	ba 07 60 01 	inc  %i5                                       
4000f07c:	80 a1 00 1d 	cmp  %g4, %i5                                  
4000f080:	08 80 00 12 	bleu  4000f0c8 <rtems_bdbuf_execute_transfer_request+0x11c><== ALWAYS TAKEN
4000f084:	b8 07 20 10 	add  %i4, 0x10, %i4                            
  {                                                                   
    rtems_bdbuf_buffer *bd = req->bufs [transfer_index].user;         
4000f088:	d0 07 20 24 	ld  [ %i4 + 0x24 ], %o0                        
    bool waiters = bd->waiters;                                       
4000f08c:	c4 02 20 24 	ld  [ %o0 + 0x24 ], %g2                        
                                                                      
    if (waiters)                                                      
4000f090:	80 a0 a0 00 	cmp  %g2, 0                                    
4000f094:	32 bf ff e9 	bne,a   4000f038 <rtems_bdbuf_execute_transfer_request+0x8c>
4000f098:	a8 10 20 01 	mov  1, %l4                                    
      wake_transfer_waiters = true;                                   
    else                                                              
      wake_buffer_waiters = true;                                     
4000f09c:	10 bf ff e7 	b  4000f038 <rtems_bdbuf_execute_transfer_request+0x8c>
4000f0a0:	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;                                                  
4000f0a4:	e4 22 20 20 	st  %l2, [ %o0 + 0x20 ]                        
4000f0a8:	e2 22 00 00 	st  %l1, [ %o0 ]                               
  tail->previous = the_node;                                          
4000f0ac:	d0 24 20 48 	st  %o0, [ %l0 + 0x48 ]                        
  old_last->next = the_node;                                          
4000f0b0:	d0 20 40 00 	st  %o0, [ %g1 ]                               
  the_node->previous = old_last;                                      
4000f0b4:	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)
4000f0b8:	ba 07 60 01 	inc  %i5                                       
4000f0bc:	80 a1 00 1d 	cmp  %g4, %i5                                  
4000f0c0:	18 bf ff f2 	bgu  4000f088 <rtems_bdbuf_execute_transfer_request+0xdc>
4000f0c4:	b8 07 20 10 	add  %i4, 0x10, %i4                            
                                                                      
    if (rtems_bdbuf_tracer)                                           
      rtems_bdbuf_show_users ("transfer", bd);                        
  }                                                                   
                                                                      
  if (wake_transfer_waiters)                                          
4000f0c8:	80 8d 20 ff 	btst  0xff, %l4                                
4000f0cc:	12 80 00 2c 	bne  4000f17c <rtems_bdbuf_execute_transfer_request+0x1d0>
4000f0d0:	11 10 00 71 	sethi  %hi(0x4001c400), %o0                    
    rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);                 
                                                                      
  if (wake_buffer_waiters)                                            
4000f0d4:	80 8e e0 ff 	btst  0xff, %i3                                
4000f0d8:	12 80 00 18 	bne  4000f138 <rtems_bdbuf_execute_transfer_request+0x18c>
4000f0dc:	11 10 00 71 	sethi  %hi(0x4001c400), %o0                    
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
                                                                      
  if (!cache_locked)                                                  
4000f0e0:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f0e4:	02 80 00 1a 	be  4000f14c <rtems_bdbuf_execute_transfer_request+0x1a0>
4000f0e8:	01 00 00 00 	nop                                            
    rtems_bdbuf_unlock_cache ();                                      
                                                                      
  if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)              
4000f0ec:	80 a6 20 0d 	cmp  %i0, 0xd                                  
4000f0f0:	02 80 00 04 	be  4000f100 <rtems_bdbuf_execute_transfer_request+0x154>
4000f0f4:	80 a6 20 00 	cmp  %i0, 0                                    
4000f0f8:	32 80 00 02 	bne,a   4000f100 <rtems_bdbuf_execute_transfer_request+0x154>
4000f0fc:	b0 10 20 1b 	mov  0x1b, %i0                                 
    return sc;                                                        
  else                                                                
    return RTEMS_IO_ERROR;                                            
}                                                                     
4000f100:	81 c7 e0 08 	ret                                            
4000f104:	81 e8 00 00 	restore                                        
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.read_errors;                                        
  }                                                                   
  else                                                                
  {                                                                   
    dd->stats.write_blocks += req->bufnum;                            
4000f108:	c4 07 60 5c 	ld  [ %i5 + 0x5c ], %g2                        
    ++dd->stats.write_transfers;                                      
4000f10c:	c2 07 60 58 	ld  [ %i5 + 0x58 ], %g1                        
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.read_errors;                                        
  }                                                                   
  else                                                                
  {                                                                   
    dd->stats.write_blocks += req->bufnum;                            
4000f110:	84 00 80 04 	add  %g2, %g4, %g2                             
    ++dd->stats.write_transfers;                                      
4000f114:	82 00 60 01 	inc  %g1                                       
    if (sc != RTEMS_SUCCESSFUL)                                       
      ++dd->stats.read_errors;                                        
  }                                                                   
  else                                                                
  {                                                                   
    dd->stats.write_blocks += req->bufnum;                            
4000f118:	c4 27 60 5c 	st  %g2, [ %i5 + 0x5c ]                        
    ++dd->stats.write_transfers;                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
4000f11c:	80 a6 20 00 	cmp  %i0, 0                                    
4000f120:	02 bf ff ba 	be  4000f008 <rtems_bdbuf_execute_transfer_request+0x5c>
4000f124:	c2 27 60 58 	st  %g1, [ %i5 + 0x58 ]                        
      ++dd->stats.write_errors;                                       
4000f128:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
4000f12c:	82 00 60 01 	inc  %g1                                       
4000f130:	10 bf ff b6 	b  4000f008 <rtems_bdbuf_execute_transfer_request+0x5c>
4000f134:	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);                   
4000f138:	7f ff fc 52 	call  4000e280 <rtems_bdbuf_wake>              
4000f13c:	90 12 22 00 	or  %o0, 0x200, %o0                            
                                                                      
  if (!cache_locked)                                                  
4000f140:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f144:	32 bf ff eb 	bne,a   4000f0f0 <rtems_bdbuf_execute_transfer_request+0x144>
4000f148:	80 a6 20 0d 	cmp  %i0, 0xd                                  
    rtems_bdbuf_unlock_cache ();                                      
4000f14c:	7f ff fb ac 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000f150:	01 00 00 00 	nop                                            
                                                                      
  if (sc == RTEMS_SUCCESSFUL || sc == RTEMS_UNSATISFIED)              
4000f154:	10 bf ff e7 	b  4000f0f0 <rtems_bdbuf_execute_transfer_request+0x144>
4000f158:	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;                                        
4000f15c:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
4000f160:	82 00 60 01 	inc  %g1                                       
4000f164:	10 bf ff a9 	b  4000f008 <rtems_bdbuf_execute_transfer_request+0x5c>
4000f168:	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 ();                                      
4000f16c:	7f ff fb a4 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000f170:	01 00 00 00 	nop                                            
                                                                      
  /* The return value will be ignored for transfer requests */        
  dd->ioctl (dd->phys_dev, RTEMS_BLKIO_REQUEST, req);                 
4000f174:	10 bf ff 93 	b  4000efc0 <rtems_bdbuf_execute_transfer_request+0x14>
4000f178:	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);                 
4000f17c:	7f ff fc 41 	call  4000e280 <rtems_bdbuf_wake>              
4000f180:	90 12 21 f8 	or  %o0, 0x1f8, %o0                            
                                                                      
  if (wake_buffer_waiters)                                            
4000f184:	10 bf ff d5 	b  4000f0d8 <rtems_bdbuf_execute_transfer_request+0x12c>
4000f188:	80 8e e0 ff 	btst  0xff, %i3                                
                                                                      

4000df5c <rtems_bdbuf_fatal>: #define RTEMS_BDBUF_AVL_MAX_HEIGHT (32) #endif static void rtems_bdbuf_fatal (rtems_fatal_code error) {
4000df5c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_fatal (RTEMS_FATAL_SOURCE_BDBUF, error);                      
4000df60:	90 10 20 03 	mov  3, %o0                                    <== NOT EXECUTED
4000df64:	7f ff f0 53 	call  4000a0b0 <rtems_fatal>                   <== NOT EXECUTED
4000df68:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
                                                                      

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

4000fd8c <rtems_bdbuf_get>: rtems_status_code rtems_bdbuf_get (rtems_disk_device *dd, rtems_blkdev_bnum block, rtems_bdbuf_buffer **bd_ptr) {
4000fd8c:	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 ();                                          
4000fd90:	7f ff f8 85 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
4000fd94:	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)                                        
4000fd98:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
4000fd9c:	80 a6 40 01 	cmp  %i1, %g1                                  
4000fda0:	0a 80 00 07 	bcs  4000fdbc <rtems_bdbuf_get+0x30>           <== ALWAYS TAKEN
4000fda4:	ba 10 20 00 	clr  %i5                                       
      rtems_bdbuf_show_users ("get", bd);                             
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000fda8:	7f ff f8 95 	call  4000dffc <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000fdac:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
                                                                      
  *bd_ptr = bd;                                                       
4000fdb0:	fa 26 80 00 	st  %i5, [ %i2 ]                               <== NOT EXECUTED
                                                                      
  return sc;                                                          
}                                                                     
4000fdb4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fdb8:	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)                            
4000fdbc:	d2 06 20 30 	ld  [ %i0 + 0x30 ], %o1                        
4000fdc0:	80 a2 60 00 	cmp  %o1, 0                                    
4000fdc4:	26 80 00 29 	bl,a   4000fe68 <rtems_bdbuf_get+0xdc>         <== NEVER TAKEN
4000fdc8:	d6 06 20 24 	ld  [ %i0 + 0x24 ], %o3                        <== NOT EXECUTED
    return block << dd->block_to_media_block_shift;                   
4000fdcc:	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;
4000fdd0:	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);         
4000fdd4:	90 10 00 18 	mov  %i0, %o0                                  
4000fdd8:	7f ff fb df 	call  4000ed54 <rtems_bdbuf_get_buffer_for_access>
4000fddc:	92 02 40 01 	add  %o1, %g1, %o1                             
4000fde0:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
    switch (bd->state)                                                
4000fde4:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0                        
4000fde8:	80 a2 20 02 	cmp  %o0, 2                                    
4000fdec:	02 80 00 17 	be  4000fe48 <rtems_bdbuf_get+0xbc>            
4000fdf0:	80 a2 20 07 	cmp  %o0, 7                                    
4000fdf4:	02 80 00 06 	be  4000fe0c <rtems_bdbuf_get+0x80>            
4000fdf8:	80 a2 20 01 	cmp  %o0, 1                                    
4000fdfc:	02 80 00 0c 	be  4000fe2c <rtems_bdbuf_get+0xa0>            <== ALWAYS TAKEN
4000fe00:	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);
4000fe04:	7f ff f8 6e 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000fe08:	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;                                                  
4000fe0c:	82 10 20 04 	mov  4, %g1                                    
4000fe10:	b8 10 20 00 	clr  %i4                                       
4000fe14:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
      rtems_bdbuf_show_users ("get", bd);                             
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000fe18:	7f ff f8 79 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000fe1c:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  *bd_ptr = bd;                                                       
4000fe20:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
  return sc;                                                          
}                                                                     
4000fe24:	81 c7 e0 08 	ret                                            
4000fe28:	81 e8 00 00 	restore                                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000fe2c:	b8 10 20 00 	clr  %i4                                       
4000fe30:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
      rtems_bdbuf_show_users ("get", bd);                             
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000fe34:	7f ff f8 72 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000fe38:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  *bd_ptr = bd;                                                       
4000fe3c:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
  return sc;                                                          
}                                                                     
4000fe40:	81 c7 e0 08 	ret                                            
4000fe44:	81 e8 00 00 	restore                                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
4000fe48:	82 10 20 03 	mov  3, %g1                                    
4000fe4c:	b8 10 20 00 	clr  %i4                                       
4000fe50:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
      rtems_bdbuf_show_users ("get", bd);                             
      rtems_bdbuf_show_usage ();                                      
    }                                                                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000fe54:	7f ff f8 6a 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000fe58:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  *bd_ptr = bd;                                                       
4000fe5c:	fa 26 80 00 	st  %i5, [ %i2 ]                               
                                                                      
  return sc;                                                          
}                                                                     
4000fe60:	81 c7 e0 08 	ret                                            
4000fe64:	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); 
4000fe68:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000fe6c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4000fe70:	40 00 24 3d 	call  40018f64 <__muldi3>                      <== NOT EXECUTED
4000fe74:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4000fe78:	d6 06 20 20 	ld  [ %i0 + 0x20 ], %o3                        <== NOT EXECUTED
4000fe7c:	40 00 26 4b 	call  400197a8 <__udivdi3>                     <== NOT EXECUTED
4000fe80:	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;
4000fe84:	10 bf ff d4 	b  4000fdd4 <rtems_bdbuf_get+0x48>             <== NOT EXECUTED
4000fe88:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        <== NOT EXECUTED
                                                                      

4000ed54 <rtems_bdbuf_get_buffer_for_access>: static rtems_bdbuf_buffer * rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd, rtems_blkdev_bnum block) {
4000ed54:	9d e3 bf a0 	save  %sp, -96, %sp                            
4000ed58:	3b 10 00 71 	sethi  %hi(0x4001c400), %i5                    
4000ed5c:	b8 10 00 18 	mov  %i0, %i4                                  
4000ed60:	ba 17 61 8c 	or  %i5, 0x18c, %i5                            
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
4000ed64:	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);         
4000ed68:	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);           
4000ed6c:	b4 07 60 64 	add  %i5, 0x64, %i2                            
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000ed70:	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);   
4000ed74:	a2 07 60 74 	add  %i5, 0x74, %l1                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_wait_for_buffer (void)                                    
{                                                                     
  if (!rtems_chain_is_empty (&bdbuf_cache.modified))                  
4000ed78:	a4 07 60 50 	add  %i5, 0x50, %l2                            
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
4000ed7c:	d0 07 60 3c 	ld  [ %i5 + 0x3c ], %o0                        
4000ed80:	92 10 00 1c 	mov  %i4, %o1                                  
4000ed84:	7f ff fd 26 	call  4000e21c <rtems_bdbuf_avl_search.isra.0> 
4000ed88:	94 10 00 19 	mov  %i1, %o2                                  
                                                                      
    if (bd != NULL)                                                   
4000ed8c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000ed90:	02 80 00 34 	be  4000ee60 <rtems_bdbuf_get_buffer_for_access+0x10c>
4000ed94:	90 10 00 1c 	mov  %i4, %o0                                  
    {                                                                 
      if (bd->group->bds_per_group != dd->bds_per_group)              
4000ed98:	c4 06 20 28 	ld  [ %i0 + 0x28 ], %g2                        
4000ed9c:	c2 07 20 34 	ld  [ %i4 + 0x34 ], %g1                        
4000eda0:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
4000eda4:	80 a0 80 01 	cmp  %g2, %g1                                  
4000eda8:	12 80 00 0c 	bne  4000edd8 <rtems_bdbuf_get_buffer_for_access+0x84>
4000edac:	2d 10 00 37 	sethi  %hi(0x4000dc00), %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);         
4000edb0:	3b 10 00 71 	sethi  %hi(0x4001c400), %i5                    
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000edb4:	39 10 00 37 	sethi  %hi(0x4000dc00), %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);         
4000edb8:	ba 17 61 f8 	or  %i5, 0x1f8, %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);           
4000edbc:	b6 07 7f f8 	add  %i5, -8, %i3                              
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000edc0:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000edc4:	80 a2 20 0a 	cmp  %o0, 0xa                                  
4000edc8:	08 80 00 4c 	bleu  4000eef8 <rtems_bdbuf_get_buffer_for_access+0x1a4><== ALWAYS TAKEN
4000edcc:	84 17 21 54 	or  %i4, 0x154, %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);
4000edd0:	7f ff fc 7b 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000edd4:	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;                                                  
4000edd8:	aa 10 20 08 	mov  8, %l5                                    
)                                                                     
{                                                                     
  Chain_Node *tail = _Chain_Tail( the_chain );                        
  Chain_Node *old_last = tail->previous;                              
                                                                      
  the_node->next = tail;                                              
4000eddc:	a8 07 60 5c 	add  %i5, 0x5c, %l4                            
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000ede0:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000ede4:	80 a2 20 0a 	cmp  %o0, 0xa                                  
4000ede8:	08 80 00 04 	bleu  4000edf8 <rtems_bdbuf_get_buffer_for_access+0xa4><== ALWAYS TAKEN
4000edec:	82 15 a1 80 	or  %l6, 0x180, %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);
4000edf0:	7f ff fc 73 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000edf4:	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)                                                
4000edf8:	91 2a 20 02 	sll  %o0, 2, %o0                               
4000edfc:	c2 00 40 08 	ld  [ %g1 + %o0 ], %g1                         
4000ee00:	81 c0 40 00 	jmp  %g1                                       
4000ee04:	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)                                         
4000ee08:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4000ee0c:	80 a0 60 00 	cmp  %g1, 0                                    
4000ee10:	12 80 00 1f 	bne  4000ee8c <rtems_bdbuf_get_buffer_for_access+0x138><== ALWAYS TAKEN
4000ee14:	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);             
4000ee18:	7f ff fe a0 	call  4000e898 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
4000ee1c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000ee20:	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;                                                  
4000ee24:	c0 26 20 20 	clr  [ %i0 + 0x20 ]                            <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000ee28:	f6 26 20 04 	st  %i3, [ %i0 + 4 ]                           <== NOT EXECUTED
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000ee2c:	f0 27 60 40 	st  %i0, [ %i5 + 0x40 ]                        <== NOT EXECUTED
  the_node->next        = before_node;                                
4000ee30:	c2 26 00 00 	st  %g1, [ %i0 ]                               <== NOT EXECUTED
  before_node->previous = the_node;                                   
4000ee34:	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);             
4000ee38:	7f ff fd 12 	call  4000e280 <rtems_bdbuf_wake>              <== NOT EXECUTED
4000ee3c:	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);       
4000ee40:	d0 07 60 3c 	ld  [ %i5 + 0x3c ], %o0                        <== NOT EXECUTED
4000ee44:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4000ee48:	7f ff fc f5 	call  4000e21c <rtems_bdbuf_avl_search.isra.0> <== NOT EXECUTED
4000ee4c:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
                                                                      
    if (bd != NULL)                                                   
4000ee50:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4000ee54:	32 bf ff d2 	bne,a   4000ed9c <rtems_bdbuf_get_buffer_for_access+0x48><== NOT EXECUTED
4000ee58:	c4 06 20 28 	ld  [ %i0 + 0x28 ], %g2                        <== NOT EXECUTED
        bd = NULL;                                                    
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);          
4000ee5c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4000ee60:	7f ff fe a0 	call  4000e8e0 <rtems_bdbuf_get_buffer_from_lru_list>
4000ee64:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
      if (bd == NULL)                                                 
4000ee68:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000ee6c:	32 bf ff d2 	bne,a   4000edb4 <rtems_bdbuf_get_buffer_for_access+0x60>
4000ee70:	3b 10 00 71 	sethi  %hi(0x4001c400), %i5                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_wait_for_buffer (void)                                    
{                                                                     
  if (!rtems_chain_is_empty (&bdbuf_cache.modified))                  
4000ee74:	c2 04 e0 4c 	ld  [ %l3 + 0x4c ], %g1                        
4000ee78:	80 a0 40 12 	cmp  %g1, %l2                                  
4000ee7c:	02 80 00 04 	be  4000ee8c <rtems_bdbuf_get_buffer_for_access+0x138>
4000ee80:	01 00 00 00 	nop                                            
    rtems_bdbuf_wake_swapper ();                                      
4000ee84:	7f ff fc 64 	call  4000e014 <rtems_bdbuf_wake_swapper>      
4000ee88:	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);   
4000ee8c:	7f ff fc 8c 	call  4000e0bc <rtems_bdbuf_anonymous_wait>    
4000ee90:	90 10 00 11 	mov  %l1, %o0                                  
{                                                                     
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  do                                                                  
  {                                                                   
    bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);       
4000ee94:	10 bf ff bb 	b  4000ed80 <rtems_bdbuf_get_buffer_for_access+0x2c>
4000ee98:	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);         
4000ee9c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4000eea0:	7f ff fc a5 	call  4000e134 <rtems_bdbuf_wait>              <== NOT EXECUTED
4000eea4:	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)                                                
4000eea8:	10 bf ff cf 	b  4000ede4 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
4000eeac:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        <== NOT EXECUTED
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
4000eeb0:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000eeb4:	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;                                                  
4000eeb8:	ea 26 20 20 	st  %l5, [ %i0 + 0x20 ]                        <== NOT EXECUTED
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4000eebc:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
4000eec0:	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;                              
4000eec4:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        <== NOT EXECUTED
                                                                      
  the_node->next = tail;                                              
4000eec8:	e8 26 00 00 	st  %l4, [ %i0 ]                               <== NOT EXECUTED
  tail->previous = the_node;                                          
4000eecc:	f0 27 60 60 	st  %i0, [ %i5 + 0x60 ]                        <== NOT EXECUTED
  old_last->next = the_node;                                          
4000eed0:	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 ();                                        
4000eed4:	7f ff fc 50 	call  4000e014 <rtems_bdbuf_wake_swapper>      <== NOT EXECUTED
4000eed8:	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)                                                
4000eedc:	10 bf ff c2 	b  4000ede4 <rtems_bdbuf_get_buffer_for_access+0x90><== NOT EXECUTED
4000eee0:	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);           
4000eee4:	90 10 00 18 	mov  %i0, %o0                                  
4000eee8:	7f ff fc 93 	call  4000e134 <rtems_bdbuf_wait>              
4000eeec:	92 10 00 1a 	mov  %i2, %o1                                  
static bool                                                           
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)                 
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000eef0:	10 bf ff bd 	b  4000ede4 <rtems_bdbuf_get_buffer_for_access+0x90>
4000eef4:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000eef8:	83 2a 20 02 	sll  %o0, 2, %g1                               
4000eefc:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
4000ef00:	81 c0 40 00 	jmp  %g1                                       
4000ef04:	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);         
4000ef08:	90 10 00 18 	mov  %i0, %o0                                  
4000ef0c:	7f ff fc 8a 	call  4000e134 <rtems_bdbuf_wait>              
4000ef10:	92 10 00 1d 	mov  %i5, %o1                                  
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000ef14:	10 bf ff ac 	b  4000edc4 <rtems_bdbuf_get_buffer_for_access+0x70>
4000ef18:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4000ef1c:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
4000ef20:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000ef24:	84 00 bf ff 	add  %g2, -1, %g2                              
4000ef28:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000ef2c:	c6 06 00 00 	ld  [ %i0 ], %g3                               
  previous       = the_node->previous;                                
4000ef30:	c4 06 20 04 	ld  [ %i0 + 4 ], %g2                           
  next->previous = previous;                                          
4000ef34:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
4000ef38:	c6 20 80 00 	st  %g3, [ %g2 ]                               
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
4000ef3c:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4000ef40:	84 00 a0 01 	inc  %g2                                       
4000ef44:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
4000ef48:	81 c7 e0 08 	ret                                            
4000ef4c:	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);           
4000ef50:	90 10 00 18 	mov  %i0, %o0                                  
4000ef54:	7f ff fc 78 	call  4000e134 <rtems_bdbuf_wait>              
4000ef58:	92 10 00 1b 	mov  %i3, %o1                                  
static void                                                           
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)                  
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4000ef5c:	10 bf ff 9a 	b  4000edc4 <rtems_bdbuf_get_buffer_for_access+0x70>
4000ef60:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000ef64:	10 bf ff f2 	b  4000ef2c <rtems_bdbuf_get_buffer_for_access+0x1d8>
4000ef68:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
4000ef6c:	10 bf ff f4 	b  4000ef3c <rtems_bdbuf_get_buffer_for_access+0x1e8>
4000ef70:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
                                                                      

4000ecf8 <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) {
4000ecf8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_bdbuf_buffer *bd = NULL;                                      
                                                                      
  bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);         
4000ecfc:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
4000ed00:	d0 00 61 c8 	ld  [ %g1 + 0x1c8 ], %o0	! 4001c5c8 <bdbuf_cache+0x3c>
4000ed04:	92 10 00 18 	mov  %i0, %o1                                  
4000ed08:	7f ff fd 45 	call  4000e21c <rtems_bdbuf_avl_search.isra.0> 
4000ed0c:	94 10 00 19 	mov  %i1, %o2                                  
                                                                      
  if (bd == NULL)                                                     
4000ed10:	80 a2 20 00 	cmp  %o0, 0                                    
4000ed14:	02 80 00 04 	be  4000ed24 <rtems_bdbuf_get_buffer_for_read_ahead+0x2c><== ALWAYS TAKEN
4000ed18:	82 10 20 00 	clr  %g1                                       
     * thus no need for a read ahead.                                 
     */                                                               
    bd = NULL;                                                        
                                                                      
  return bd;                                                          
}                                                                     
4000ed1c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ed20:	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);            
4000ed24:	90 10 00 18 	mov  %i0, %o0                                  
4000ed28:	7f ff fe ee 	call  4000e8e0 <rtems_bdbuf_get_buffer_from_lru_list>
4000ed2c:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
    if (bd != NULL)                                                   
4000ed30:	82 92 20 00 	orcc  %o0, 0, %g1                              
4000ed34:	02 bf ff fa 	be  4000ed1c <rtems_bdbuf_get_buffer_for_read_ahead+0x24><== NEVER TAKEN
4000ed38:	01 00 00 00 	nop                                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
4000ed3c:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2                        
4000ed40:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
4000ed44:	86 00 e0 01 	inc  %g3                                       
4000ed48:	c6 20 a0 0c 	st  %g3, [ %g2 + 0xc ]                         
     * thus no need for a read ahead.                                 
     */                                                               
    bd = NULL;                                                        
                                                                      
  return bd;                                                          
}                                                                     
4000ed4c:	81 c7 e0 08 	ret                                            
4000ed50:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

4000e8e0 <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) {
4000e8e0:	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;                              
4000e8e4:	35 10 00 71 	sethi  %hi(0x4001c400), %i2                    
4000e8e8:	b4 16 a1 8c 	or  %i2, 0x18c, %i2	! 4001c58c <bdbuf_cache>   
4000e8ec:	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))               
4000e8f0:	a4 06 a0 44 	add  %i2, 0x44, %l2                            
4000e8f4:	a6 06 a0 40 	add  %i2, 0x40, %l3                            
4000e8f8:	80 a7 40 12 	cmp  %i5, %l2                                  
4000e8fc:	12 80 00 07 	bne  4000e918 <rtems_bdbuf_get_buffer_from_lru_list+0x38>
4000e900:	a8 06 a0 74 	add  %i2, 0x74, %l4                            
    }                                                                 
                                                                      
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  return NULL;                                                        
4000e904:	10 80 00 6c 	b  4000eab4 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
4000e908:	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))               
4000e90c:	80 a7 40 12 	cmp  %i5, %l2                                  
4000e910:	22 80 00 69 	be,a   4000eab4 <rtems_bdbuf_get_buffer_from_lru_list+0x1d4>
4000e914:	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)                                             
4000e918:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
4000e91c:	80 a0 60 00 	cmp  %g1, 0                                    
4000e920:	32 bf ff fb 	bne,a   4000e90c <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
4000e924:	fa 07 40 00 	ld  [ %i5 ], %i5                               
    {                                                                 
      if (bd->group->bds_per_group == dd->bds_per_group)              
4000e928:	e0 07 60 28 	ld  [ %i5 + 0x28 ], %l0                        
4000e92c:	e2 06 20 34 	ld  [ %i0 + 0x34 ], %l1                        
4000e930:	f6 04 20 08 	ld  [ %l0 + 8 ], %i3                           
4000e934:	80 a6 c0 11 	cmp  %i3, %l1                                  
4000e938:	02 80 00 37 	be  4000ea14 <rtems_bdbuf_get_buffer_from_lru_list+0x134>
4000e93c:	01 00 00 00 	nop                                            
      {                                                               
        rtems_bdbuf_remove_from_tree_and_lru_list (bd);               
                                                                      
        empty_bd = bd;                                                
      }                                                               
      else if (bd->group->users == 0)                                 
4000e940:	c2 04 20 0c 	ld  [ %l0 + 0xc ], %g1                         
4000e944:	80 a0 60 00 	cmp  %g1, 0                                    
4000e948:	32 bf ff f1 	bne,a   4000e90c <rtems_bdbuf_get_buffer_from_lru_list+0x2c>
4000e94c:	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; 
4000e950:	ec 06 a0 20 	ld  [ %i2 + 0x20 ], %l6                        
4000e954:	92 10 00 1b 	mov  %i3, %o1                                  
4000e958:	40 00 28 2b 	call  40018a04 <.udiv>                         
4000e95c:	90 10 00 16 	mov  %l6, %o0                                  
                                                                      
  for (b = 0, bd = group->bdbuf;                                      
4000e960:	80 a6 e0 00 	cmp  %i3, 0                                    
4000e964:	02 80 00 0f 	be  4000e9a0 <rtems_bdbuf_get_buffer_from_lru_list+0xc0><== NEVER TAKEN
4000e968:	f8 04 20 10 	ld  [ %l0 + 0x10 ], %i4                        
4000e96c:	83 2a 20 03 	sll  %o0, 3, %g1                               
4000e970:	ab 2a 20 06 	sll  %o0, 6, %l5                               
4000e974:	b6 10 20 00 	clr  %i3                                       
4000e978:	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);                   
4000e97c:	7f ff ff c7 	call  4000e898 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000e980:	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;                                      
4000e984:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
       b < group->bds_per_group;                                      
       b++, bd += bufs_per_bd)                                        
4000e988:	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;                                      
4000e98c:	80 a6 c0 01 	cmp  %i3, %g1                                  
4000e990:	0a bf ff fb 	bcs  4000e97c <rtems_bdbuf_get_buffer_from_lru_list+0x9c>
4000e994:	b8 07 00 15 	add  %i4, %l5, %i4                             
4000e998:	ec 06 a0 20 	ld  [ %i2 + 0x20 ], %l6                        
4000e99c:	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;                           
4000e9a0:	e2 24 20 08 	st  %l1, [ %l0 + 8 ]                           
  bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;    
4000e9a4:	90 10 00 16 	mov  %l6, %o0                                  
4000e9a8:	40 00 28 17 	call  40018a04 <.udiv>                         
4000e9ac:	92 10 00 11 	mov  %l1, %o1                                  
                                                                      
  for (b = 1, bd = group->bdbuf + bufs_per_bd;                        
4000e9b0:	83 2a 20 03 	sll  %o0, 3, %g1                               
4000e9b4:	89 2a 20 06 	sll  %o0, 6, %g4                               
4000e9b8:	80 a4 60 01 	cmp  %l1, 1                                    
4000e9bc:	88 21 00 01 	sub  %g4, %g1, %g4                             
4000e9c0:	08 80 00 10 	bleu  4000ea00 <rtems_bdbuf_get_buffer_from_lru_list+0x120>
4000e9c4:	82 07 00 04 	add  %i4, %g4, %g1                             
4000e9c8:	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;                                                  
4000e9cc:	c0 20 60 20 	clr  [ %g1 + 0x20 ]                            
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000e9d0:	c6 06 a0 40 	ld  [ %i2 + 0x40 ], %g3                        
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000e9d4:	e6 20 60 04 	st  %l3, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000e9d8:	c2 26 a0 40 	st  %g1, [ %i2 + 0x40 ]                        
  the_node->next        = before_node;                                
4000e9dc:	c6 20 40 00 	st  %g3, [ %g1 ]                               
  before_node->previous = the_node;                                   
4000e9e0:	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)                                        
4000e9e4:	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;                        
4000e9e8:	80 a0 80 11 	cmp  %g2, %l1                                  
4000e9ec:	12 bf ff f8 	bne  4000e9cc <rtems_bdbuf_get_buffer_from_lru_list+0xec>
4000e9f0:	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);                   
4000e9f4:	7f ff fe 23 	call  4000e280 <rtems_bdbuf_wake>              
4000e9f8:	90 10 00 14 	mov  %l4, %o0                                  
4000e9fc:	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)                                             
4000ea00:	80 a7 20 00 	cmp  %i4, 0                                    
4000ea04:	22 bf ff c2 	be,a   4000e90c <rtems_bdbuf_get_buffer_from_lru_list+0x2c><== NEVER TAKEN
4000ea08:	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;                                                
4000ea0c:	10 80 00 04 	b  4000ea1c <rtems_bdbuf_get_buffer_from_lru_list+0x13c>
4000ea10:	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);               
4000ea14:	7f ff ff a1 	call  4000e898 <rtems_bdbuf_remove_from_tree_and_lru_list>
4000ea18:	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 ;                                                
4000ea1c:	f0 27 60 14 	st  %i0, [ %i5 + 0x14 ]                        
  bd->block     = block;                                              
  bd->avl.left  = NULL;                                               
4000ea20:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
  bd->avl.right = NULL;                                               
4000ea24:	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;                                     
4000ea28:	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;                                              
4000ea2c:	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)                                                      
4000ea30:	80 a0 60 00 	cmp  %g1, 0                                    
4000ea34:	02 80 00 5c 	be  4000eba4 <rtems_bdbuf_get_buffer_from_lru_list+0x2c4>
4000ea38:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000ea3c:	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;                          
4000ea40:	9e 07 bf 80 	add  %fp, -128, %o7                            
4000ea44:	84 10 00 0f 	mov  %o7, %g2                                  
    return 0;                                                         
  }                                                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
4000ea48:	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;                                               
4000ea4c:	b8 10 20 01 	mov  1, %i4                                    
        break;                                                        
      }                                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
    {                                                                 
      p->avl.cache = -1;                                              
4000ea50:	b6 10 3f ff 	mov  -1, %i3                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000ea54:	80 a0 c0 18 	cmp  %g3, %i0                                  
4000ea58:	1a 80 00 0d 	bcc  4000ea8c <rtems_bdbuf_get_buffer_from_lru_list+0x1ac><== ALWAYS TAKEN
4000ea5c:	88 00 a0 04 	add  %g2, 4, %g4                               
        || ((p->dd == dd) && (p->block < block)))                     
    {                                                                 
      p->avl.cache = 1;                                               
      q = p->avl.right;                                               
4000ea60:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         <== NOT EXECUTED
      if (q == NULL)                                                  
4000ea64:	80 a0 e0 00 	cmp  %g3, 0                                    
4000ea68:	02 80 00 1d 	be  4000eadc <rtems_bdbuf_get_buffer_from_lru_list+0x1fc>
4000ea6c:	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)                                                      
4000ea70:	82 10 00 03 	mov  %g3, %g1                                  
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000ea74:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
4000ea78:	84 10 00 04 	mov  %g4, %g2                                  
    return 0;                                                         
  }                                                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
4000ea7c:	c2 20 80 00 	st  %g1, [ %g2 ]                               
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000ea80:	80 a0 c0 18 	cmp  %g3, %i0                                  
4000ea84:	0a bf ff f7 	bcs  4000ea60 <rtems_bdbuf_get_buffer_from_lru_list+0x180><== NEVER TAKEN
4000ea88:	88 00 a0 04 	add  %g2, 4, %g4                               
        || ((p->dd == dd) && (p->block < block)))                     
4000ea8c:	80 a6 00 03 	cmp  %i0, %g3                                  
4000ea90:	22 80 00 0b 	be,a   4000eabc <rtems_bdbuf_get_buffer_from_lru_list+0x1dc><== ALWAYS TAKEN
4000ea94:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
      }                                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
    {                                                                 
      p->avl.cache = -1;                                              
      q = p->avl.left;                                                
4000ea98:	c6 00 60 08 	ld  [ %g1 + 8 ], %g3                           <== NOT EXECUTED
      if (q == NULL)                                                  
4000ea9c:	80 a0 e0 00 	cmp  %g3, 0                                    
4000eaa0:	12 bf ff f4 	bne  4000ea70 <rtems_bdbuf_get_buffer_from_lru_list+0x190>
4000eaa4:	f6 28 60 10 	stb  %i3, [ %g1 + 0x10 ]                       
      {                                                               
        q = node;                                                     
        p->avl.left = q;                                              
4000eaa8:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
4000eaac:	10 80 00 0e 	b  4000eae4 <rtems_bdbuf_get_buffer_from_lru_list+0x204>
4000eab0:	88 10 3f ff 	mov  -1, %g4                                   
                                                                      
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  return NULL;                                                        
}                                                                     
4000eab4:	81 c7 e0 08 	ret                                            
4000eab8:	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)))                     
4000eabc:	80 a6 40 03 	cmp  %i1, %g3                                  
4000eac0:	38 bf ff e9 	bgu,a   4000ea64 <rtems_bdbuf_get_buffer_from_lru_list+0x184>
4000eac4:	c6 00 60 0c 	ld  [ %g1 + 0xc ], %g3                         
        q = node;                                                     
        p->avl.right = q = node;                                      
        break;                                                        
      }                                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
4000eac8:	80 a6 40 03 	cmp  %i1, %g3                                  
4000eacc:	32 bf ff f4 	bne,a   4000ea9c <rtems_bdbuf_get_buffer_from_lru_list+0x1bc><== ALWAYS TAKEN
4000ead0:	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);                    
4000ead4:	7f ff fd 22 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000ead8:	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;                                      
4000eadc:	fa 20 60 0c 	st  %i5, [ %g1 + 0xc ]                         
4000eae0:	88 10 20 01 	mov  1, %g4                                    
    }                                                                 
                                                                      
    p = q;                                                            
  }                                                                   
                                                                      
  q->avl.left = q->avl.right = NULL;                                  
4000eae4:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
4000eae8:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
  q->avl.bal = 0;                                                     
4000eaec:	c0 2f 60 11 	clrb  [ %i5 + 0x11 ]                           
4000eaf0:	89 29 20 18 	sll  %g4, 0x18, %g4                            
          p->avl.bal = 0;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case 0:                                                       
          p->avl.bal = 1;                                             
4000eaf4:	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;
4000eaf8:	10 80 00 12 	b  4000eb40 <rtems_bdbuf_get_buffer_from_lru_list+0x260>
4000eafc:	b0 10 3f ff 	mov  -1, %i0                                   
          p->avl.bal = 0;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case 0:                                                       
          p->avl.bal = 1;                                             
4000eb00:	86 10 00 01 	mov  %g1, %g3                                  
4000eb04:	b8 10 20 01 	mov  1, %i4                                    
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
    q = p;                                                            
    if (buf_prev > buf_stack)                                         
4000eb08:	80 a0 80 0f 	cmp  %g2, %o7                                  
4000eb0c:	28 80 00 1e 	bleu,a   4000eb84 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
4000eb10:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        
    {                                                                 
      p = *--buf_prev;                                                
4000eb14:	c2 00 bf fc 	ld  [ %g2 + -4 ], %g1                          
                                                                      
      if (p->avl.cache == -1)                                         
4000eb18:	c8 08 60 10 	ldub  [ %g1 + 0x10 ], %g4                      
4000eb1c:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4000eb20:	b7 39 20 18 	sra  %g4, 0x18, %i3                            
4000eb24:	80 a6 ff ff 	cmp  %i3, -1                                   
4000eb28:	22 80 00 03 	be,a   4000eb34 <rtems_bdbuf_get_buffer_from_lru_list+0x254>
4000eb2c:	c6 20 60 08 	st  %g3, [ %g1 + 8 ]                           
      {                                                               
        p->avl.left = q;                                              
      }                                                               
      else                                                            
      {                                                               
        p->avl.right = q;                                             
4000eb30:	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)                                                    
4000eb34:	80 8f 20 ff 	btst  0xff, %i4                                
4000eb38:	02 80 00 13 	be  4000eb84 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4>
4000eb3c:	84 00 bf fc 	add  %g2, -4, %g2                              
  {                                                                   
    if (p->avl.cache == -1)                                           
4000eb40:	89 39 20 18 	sra  %g4, 0x18, %g4                            
4000eb44:	80 a1 3f ff 	cmp  %g4, -1                                   
4000eb48:	02 80 00 1e 	be  4000ebc0 <rtems_bdbuf_get_buffer_from_lru_list+0x2e0>
4000eb4c:	c6 48 60 11 	ldsb  [ %g1 + 0x11 ], %g3                      
          break;                                                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      switch (p->avl.bal)                                             
4000eb50:	80 a0 e0 00 	cmp  %g3, 0                                    
4000eb54:	22 bf ff eb 	be,a   4000eb00 <rtems_bdbuf_get_buffer_from_lru_list+0x220>
4000eb58:	f2 28 60 11 	stb  %i1, [ %g1 + 0x11 ]                       
4000eb5c:	80 a0 e0 01 	cmp  %g3, 1                                    
4000eb60:	02 80 00 1f 	be  4000ebdc <rtems_bdbuf_get_buffer_from_lru_list+0x2fc>
4000eb64:	80 a0 ff ff 	cmp  %g3, -1                                   
4000eb68:	22 80 00 0c 	be,a   4000eb98 <rtems_bdbuf_get_buffer_from_lru_list+0x2b8><== ALWAYS TAKEN
4000eb6c:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
4000eb70:	86 10 00 01 	mov  %g1, %g3                                  <== NOT EXECUTED
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
    q = p;                                                            
    if (buf_prev > buf_stack)                                         
4000eb74:	80 a0 80 0f 	cmp  %g2, %o7                                  <== NOT EXECUTED
4000eb78:	18 bf ff e7 	bgu  4000eb14 <rtems_bdbuf_get_buffer_from_lru_list+0x234><== NOT EXECUTED
4000eb7c:	b8 10 20 01 	mov  1, %i4                                    <== NOT EXECUTED
        p->avl.right = q;                                             
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      *root = p;                                                      
4000eb80:	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;                                                  
4000eb84:	82 10 20 01 	mov  1, %g1                                    
4000eb88:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
                                                                      
    node = rtems_chain_next (node);                                   
  }                                                                   
                                                                      
  return NULL;                                                        
}                                                                     
4000eb8c:	81 c7 e0 08 	ret                                            
4000eb90:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
    else                                                              
    {                                                                 
      switch (p->avl.bal)                                             
      {                                                               
        case -1:                                                      
          p->avl.bal = 0;                                             
4000eb94:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
4000eb98:	86 10 00 01 	mov  %g1, %g3                                  
          modified = false;                                           
4000eb9c:	10 bf ff db 	b  4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000eba0:	b8 10 20 00 	clr  %i4                                       
                                                                      
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
  {                                                                   
    *root = node;                                                     
4000eba4:	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;                                                  
4000eba8:	82 10 20 01 	mov  1, %g1                                    
  bool modified = false;                                              
                                                                      
  if (p == NULL)                                                      
  {                                                                   
    *root = node;                                                     
    node->avl.left = NULL;                                            
4000ebac:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
    node->avl.right = NULL;                                           
4000ebb0:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
    node->avl.bal = 0;                                                
4000ebb4:	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;                                                  
4000ebb8:	10 bf ff f5 	b  4000eb8c <rtems_bdbuf_get_buffer_from_lru_list+0x2ac>
4000ebbc:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
                                                                      
  while (modified)                                                    
  {                                                                   
    if (p->avl.cache == -1)                                           
    {                                                                 
      switch (p->avl.bal)                                             
4000ebc0:	80 a0 e0 00 	cmp  %g3, 0                                    
4000ebc4:	12 80 00 20 	bne  4000ec44 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
4000ebc8:	80 a0 e0 01 	cmp  %g3, 1                                    
          p->avl.bal = 0;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case 0:                                                       
          p->avl.bal = -1;                                            
4000ebcc:	c8 28 60 11 	stb  %g4, [ %g1 + 0x11 ]                       
4000ebd0:	86 10 00 01 	mov  %g1, %g3                                  
4000ebd4:	10 bf ff cd 	b  4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ebd8:	b8 10 20 01 	mov  1, %i4                                    
        case 0:                                                       
          p->avl.bal = 1;                                             
          break;                                                      
                                                                      
        case 1:                                                       
          p1 = p->avl.right;                                          
4000ebdc:	c8 00 60 0c 	ld  [ %g1 + 0xc ], %g4                         
          if (p1->avl.bal == 1) /* simple RR-turn */                  
4000ebe0:	c6 49 20 11 	ldsb  [ %g4 + 0x11 ], %g3                      
4000ebe4:	80 a0 e0 01 	cmp  %g3, 1                                    
4000ebe8:	02 80 00 32 	be  4000ecb0 <rtems_bdbuf_get_buffer_from_lru_list+0x3d0>
4000ebec:	c6 01 20 08 	ld  [ %g4 + 8 ], %g3                           
            p = p1;                                                   
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
4000ebf0:	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;
4000ebf4:	f8 48 e0 11 	ldsb  [ %g3 + 0x11 ], %i4                      
            p = p1;                                                   
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
            p1->avl.left = p2->avl.right;                             
4000ebf8:	f6 21 20 08 	st  %i3, [ %g4 + 8 ]                           
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
4000ebfc:	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;                                       
4000ec00:	c8 20 e0 0c 	st  %g4, [ %g3 + 0xc ]                         
            p->avl.right = p2->avl.left;                              
4000ec04:	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;
4000ec08:	80 a7 20 01 	cmp  %i4, 1                                    
4000ec0c:	02 80 00 30 	be  4000eccc <rtems_bdbuf_get_buffer_from_lru_list+0x3ec><== NEVER TAKEN
4000ec10:	c2 20 e0 08 	st  %g1, [ %g3 + 8 ]                           
4000ec14:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
            if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
4000ec18:	c2 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g1                      
4000ec1c:	80 a0 7f ff 	cmp  %g1, -1                                   
4000ec20:	22 80 00 06 	be,a   4000ec38 <rtems_bdbuf_get_buffer_from_lru_list+0x358><== NEVER TAKEN
4000ec24:	f2 29 20 11 	stb  %i1, [ %g4 + 0x11 ]                       <== NOT EXECUTED
4000ec28:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
            p = p2;                                                   
          }                                                           
          p->avl.bal = 0;                                             
4000ec2c:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
          modified = false;                                           
4000ec30:	10 bf ff b6 	b  4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ec34:	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;                                             
4000ec38:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           <== NOT EXECUTED
          modified = false;                                           
4000ec3c:	10 bf ff b3 	b  4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228><== NOT EXECUTED
4000ec40:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
                                                                      
  while (modified)                                                    
  {                                                                   
    if (p->avl.cache == -1)                                           
    {                                                                 
      switch (p->avl.bal)                                             
4000ec44:	02 bf ff d4 	be  4000eb94 <rtems_bdbuf_get_buffer_from_lru_list+0x2b4>
4000ec48:	80 a0 ff ff 	cmp  %g3, -1                                   
4000ec4c:	32 bf ff ca 	bne,a   4000eb74 <rtems_bdbuf_get_buffer_from_lru_list+0x294><== NEVER TAKEN
4000ec50:	86 10 00 01 	mov  %g1, %g3                                  <== NOT EXECUTED
        case 0:                                                       
          p->avl.bal = -1;                                            
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
4000ec54:	c8 00 60 08 	ld  [ %g1 + 8 ], %g4                           
          if (p1->avl.bal == -1) /* simple LL-turn */                 
4000ec58:	c6 49 20 11 	ldsb  [ %g4 + 0x11 ], %g3                      
4000ec5c:	80 a0 ff ff 	cmp  %g3, -1                                   
4000ec60:	02 80 00 1d 	be  4000ecd4 <rtems_bdbuf_get_buffer_from_lru_list+0x3f4>
4000ec64:	c6 01 20 0c 	ld  [ %g4 + 0xc ], %g3                         
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
4000ec68:	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;
4000ec6c:	f8 48 e0 11 	ldsb  [ %g3 + 0x11 ], %i4                      
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
            p1->avl.right = p2->avl.left;                             
4000ec70:	f6 21 20 0c 	st  %i3, [ %g4 + 0xc ]                         
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
4000ec74:	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;                                        
4000ec78:	c8 20 e0 08 	st  %g4, [ %g3 + 8 ]                           
            p->avl.left = p2->avl.right;                              
4000ec7c:	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;
4000ec80:	80 a7 3f ff 	cmp  %i4, -1                                   
4000ec84:	02 80 00 1b 	be  4000ecf0 <rtems_bdbuf_get_buffer_from_lru_list+0x410>
4000ec88:	c2 20 e0 0c 	st  %g1, [ %g3 + 0xc ]                         
4000ec8c:	c0 28 60 11 	clrb  [ %g1 + 0x11 ]                           
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000ec90:	c2 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g1                      
4000ec94:	80 a0 60 01 	cmp  %g1, 1                                    
4000ec98:	32 bf ff e5 	bne,a   4000ec2c <rtems_bdbuf_get_buffer_from_lru_list+0x34c>
4000ec9c:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
4000eca0:	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;                                             
4000eca4:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
          modified = false;                                           
4000eca8:	10 bf ff 98 	b  4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ecac:	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;                              
4000ecb0:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
            p1->avl.left = p;                                         
            p->avl.bal = 0;                                           
4000ecb4:	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;                                         
4000ecb8:	c2 21 20 08 	st  %g1, [ %g4 + 8 ]                           
            p->avl.bal = 0;                                           
4000ecbc:	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;                                           
4000ecc0:	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;                                             
4000ecc4:	10 bf ff 91 	b  4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ecc8:	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;
4000eccc:	10 bf ff d3 	b  4000ec18 <rtems_bdbuf_get_buffer_from_lru_list+0x338><== NOT EXECUTED
4000ecd0:	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;                              
4000ecd4:	c6 20 60 08 	st  %g3, [ %g1 + 8 ]                           
            p1->avl.right = p;                                        
            p->avl.bal = 0;                                           
4000ecd8:	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;                                        
4000ecdc:	c2 21 20 0c 	st  %g1, [ %g4 + 0xc ]                         
            p->avl.bal = 0;                                           
4000ece0:	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;                                           
4000ece4:	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;                                             
4000ece8:	10 bf ff 88 	b  4000eb08 <rtems_bdbuf_get_buffer_from_lru_list+0x228>
4000ecec:	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;
4000ecf0:	10 bf ff e8 	b  4000ec90 <rtems_bdbuf_get_buffer_from_lru_list+0x3b0>
4000ecf4:	f2 28 60 11 	stb  %i1, [ %g1 + 0x11 ]                       
                                                                      

4000f960 <rtems_bdbuf_init>: * * @return rtems_status_code The initialisation status. */ rtems_status_code rtems_bdbuf_init (void) {
4000f960:	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())                               
4000f964:	03 10 00 73 	sethi  %hi(0x4001cc00), %g1                    
4000f968:	c2 00 63 b8 	ld  [ %g1 + 0x3b8 ], %g1	! 4001cfb8 <_Per_CPU_Information+0x8>
4000f96c:	80 a0 60 00 	cmp  %g1, 0                                    
4000f970:	12 80 00 16 	bne  4000f9c8 <rtems_bdbuf_init+0x68>          <== NEVER TAKEN
4000f974:	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)       
4000f978:	3b 10 00 6a 	sethi  %hi(0x4001a800), %i5                    
4000f97c:	ba 17 63 d8 	or  %i5, 0x3d8, %i5	! 4001abd8 <rtems_bdbuf_configuration>
4000f980:	f4 07 60 28 	ld  [ %i5 + 0x28 ], %i2                        
4000f984:	f6 07 60 24 	ld  [ %i5 + 0x24 ], %i3                        
4000f988:	90 10 00 1a 	mov  %i2, %o0                                  
4000f98c:	92 10 00 1b 	mov  %i3, %o1                                  
4000f990:	40 00 24 c9 	call  40018cb4 <.urem>                         
4000f994:	b0 10 20 0a 	mov  0xa, %i0                                  
4000f998:	80 a2 20 00 	cmp  %o0, 0                                    
4000f99c:	12 80 00 fa 	bne  4000fd84 <rtems_bdbuf_init+0x424>         <== NEVER TAKEN
4000f9a0:	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 ();                      
4000f9a4:	7f ff f9 a9 	call  4000e048 <rtems_bdbuf_disable_preemption>
4000f9a8:	33 10 00 71 	sethi  %hi(0x4001c400), %i1                    
  if (bdbuf_cache.initialised)                                        
4000f9ac:	b8 16 61 8c 	or  %i1, 0x18c, %i4	! 4001c58c <bdbuf_cache>   
4000f9b0:	c2 0f 20 95 	ldub  [ %i4 + 0x95 ], %g1                      
4000f9b4:	80 a0 60 00 	cmp  %g1, 0                                    
4000f9b8:	02 80 00 06 	be  4000f9d0 <rtems_bdbuf_init+0x70>           <== ALWAYS TAKEN
4000f9bc:	b0 10 00 08 	mov  %o0, %i0                                  
  {                                                                   
    rtems_bdbuf_restore_preemption (prev_mode);                       
4000f9c0:	7f ff f9 b0 	call  4000e080 <rtems_bdbuf_restore_preemption><== NOT EXECUTED
4000f9c4:	b0 10 20 0c 	mov  0xc, %i0                                  <== NOT EXECUTED
    return RTEMS_RESOURCE_IN_USE;                                     
4000f9c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f9cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));                       
4000f9d0:	92 10 20 00 	clr  %o1                                       
4000f9d4:	94 10 20 98 	mov  0x98, %o2                                 
4000f9d8:	40 00 18 bc 	call  40015cc8 <memset>                        
4000f9dc:	90 10 00 1c 	mov  %i4, %o0                                  
  bdbuf_cache.initialised = true;                                     
4000f9e0:	82 10 20 01 	mov  1, %g1                                    
  rtems_bdbuf_restore_preemption (prev_mode);                         
4000f9e4:	90 10 00 18 	mov  %i0, %o0                                  
4000f9e8:	7f ff f9 a6 	call  4000e080 <rtems_bdbuf_restore_preemption>
4000f9ec:	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;                                                  
4000f9f0:	82 07 20 0c 	add  %i4, 0xc, %g1                             
4000f9f4:	c2 27 20 08 	st  %g1, [ %i4 + 8 ]                           
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000f9f8:	82 07 20 08 	add  %i4, 8, %g1                               
4000f9fc:	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;                                                  
4000fa00:	82 07 20 50 	add  %i4, 0x50, %g1                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000fa04:	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;                                                  
4000fa08:	c2 27 20 4c 	st  %g1, [ %i4 + 0x4c ]                        
4000fa0c:	82 07 20 5c 	add  %i4, 0x5c, %g1                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000fa10:	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;                                                  
4000fa14:	c2 27 20 58 	st  %g1, [ %i4 + 0x58 ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000fa18:	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;                                                  
4000fa1c:	82 07 20 8c 	add  %i4, 0x8c, %g1                            
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000fa20:	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;                                                  
4000fa24:	c2 27 20 88 	st  %g1, [ %i4 + 0x88 ]                        
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000fa28:	84 07 20 58 	add  %i4, 0x58, %g2                            
4000fa2c:	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;                                                  
4000fa30:	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;                        
4000fa34:	c0 27 20 38 	clr  [ %i4 + 0x38 ]                            
  head->previous = NULL;                                              
4000fa38:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000fa3c:	e0 27 20 40 	st  %l0, [ %i4 + 0x40 ]                        
  head->previous = NULL;                                              
4000fa40:	c0 27 20 44 	clr  [ %i4 + 0x44 ]                            
4000fa44:	c0 27 20 50 	clr  [ %i4 + 0x50 ]                            
4000fa48:	c0 27 20 5c 	clr  [ %i4 + 0x5c ]                            
  tail->previous = head;                                              
4000fa4c:	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;                                              
4000fa50:	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'), 
4000fa54:	31 10 91 10 	sethi  %hi(0x42444000), %i0                    
  tail->previous = head;                                              
4000fa58:	c2 27 20 90 	st  %g1, [ %i4 + 0x90 ]                        
4000fa5c:	90 16 23 6c 	or  %i0, 0x36c, %o0                            
4000fa60:	92 10 20 01 	mov  1, %o1                                    
4000fa64:	94 10 20 54 	mov  0x54, %o2                                 
4000fa68:	96 10 20 00 	clr  %o3                                       
4000fa6c:	7f ff e7 35 	call  40009740 <rtems_semaphore_create>        
4000fa70:	98 07 20 28 	add  %i4, 0x28, %o4                            
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.lock);                    
  if (sc != RTEMS_SUCCESSFUL)                                         
4000fa74:	80 a2 20 00 	cmp  %o0, 0                                    
4000fa78:	02 80 00 2d 	be  4000fb2c <rtems_bdbuf_init+0x1cc>          <== ALWAYS TAKEN
4000fa7c:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
                                                                      
error:                                                                
                                                                      
  if (bdbuf_cache.read_ahead_task != 0)                               
4000fa80:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
4000fa84:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000fa88:	12 80 00 25 	bne  4000fb1c <rtems_bdbuf_init+0x1bc>         <== NOT EXECUTED
4000fa8c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_task_delete (bdbuf_cache.read_ahead_task);                  
                                                                      
  if (bdbuf_cache.swapout != 0)                                       
4000fa90:	d0 06 61 8c 	ld  [ %i1 + 0x18c ], %o0                       <== NOT EXECUTED
4000fa94:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000fa98:	12 80 00 1e 	bne  4000fb10 <rtems_bdbuf_init+0x1b0>         <== NOT EXECUTED
4000fa9c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_task_delete (bdbuf_cache.swapout);                          
                                                                      
  free (bdbuf_cache.buffers);                                         
4000faa0:	7f ff d6 2b 	call  4000534c <free>                          <== NOT EXECUTED
4000faa4:	d0 07 20 18 	ld  [ %i4 + 0x18 ], %o0                        <== NOT EXECUTED
  free (bdbuf_cache.groups);                                          
4000faa8:	7f ff d6 29 	call  4000534c <free>                          <== NOT EXECUTED
4000faac:	d0 07 20 80 	ld  [ %i4 + 0x80 ], %o0                        <== NOT EXECUTED
  free (bdbuf_cache.bds);                                             
4000fab0:	7f ff d6 27 	call  4000534c <free>                          <== NOT EXECUTED
4000fab4:	d0 07 20 14 	ld  [ %i4 + 0x14 ], %o0                        <== NOT EXECUTED
                                                                      
  rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);           
4000fab8:	7f ff e7 93 	call  40009904 <rtems_semaphore_delete>        <== NOT EXECUTED
4000fabc:	d0 07 20 78 	ld  [ %i4 + 0x78 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);           
4000fac0:	7f ff e7 91 	call  40009904 <rtems_semaphore_delete>        <== NOT EXECUTED
4000fac4:	d0 07 20 68 	ld  [ %i4 + 0x68 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);         
4000fac8:	7f ff e7 8f 	call  40009904 <rtems_semaphore_delete>        <== NOT EXECUTED
4000facc:	d0 07 20 70 	ld  [ %i4 + 0x70 ], %o0                        <== NOT EXECUTED
  rtems_semaphore_delete (bdbuf_cache.sync_lock);                     
4000fad0:	7f ff e7 8d 	call  40009904 <rtems_semaphore_delete>        <== NOT EXECUTED
4000fad4:	d0 07 20 2c 	ld  [ %i4 + 0x2c ], %o0                        <== NOT EXECUTED
                                                                      
  if (bdbuf_cache.lock != 0)                                          
4000fad8:	c2 07 20 28 	ld  [ %i4 + 0x28 ], %g1                        <== NOT EXECUTED
4000fadc:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000fae0:	12 80 00 05 	bne  4000faf4 <rtems_bdbuf_init+0x194>         <== NOT EXECUTED
4000fae4:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_unlock_cache ();                                      
    rtems_semaphore_delete (bdbuf_cache.lock);                        
  }                                                                   
                                                                      
  bdbuf_cache.initialised = false;                                    
4000fae8:	c0 2f 20 95 	clrb  [ %i4 + 0x95 ]                           <== NOT EXECUTED
                                                                      
  return RTEMS_UNSATISFIED;                                           
}                                                                     
4000faec:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000faf0:	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 ();                                      
4000faf4:	7f ff f9 42 	call  4000dffc <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000faf8:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
    rtems_semaphore_delete (bdbuf_cache.lock);                        
4000fafc:	7f ff e7 82 	call  40009904 <rtems_semaphore_delete>        <== NOT EXECUTED
4000fb00:	d0 07 20 28 	ld  [ %i4 + 0x28 ], %o0                        <== NOT EXECUTED
4000fb04:	c0 2f 20 95 	clrb  [ %i4 + 0x95 ]                           <== NOT EXECUTED
4000fb08:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000fb0c:	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);                          
4000fb10:	7f ff e8 8c 	call  40009d40 <rtems_task_delete>             <== NOT EXECUTED
4000fb14:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000fb18:	30 bf ff e2 	b,a   4000faa0 <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);                  
4000fb1c:	7f ff e8 89 	call  40009d40 <rtems_task_delete>             <== NOT EXECUTED
4000fb20:	01 00 00 00 	nop                                            <== NOT EXECUTED
                                                                      
  if (bdbuf_cache.swapout != 0)                                       
4000fb24:	10 bf ff dc 	b  4000fa94 <rtems_bdbuf_init+0x134>           <== NOT EXECUTED
4000fb28:	d0 06 61 8c 	ld  [ %i1 + 0x18c ], %o0                       <== NOT EXECUTED
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.lock);                    
  if (sc != RTEMS_SUCCESSFUL)                                         
    goto error;                                                       
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000fb2c:	7f ff f9 1e 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
4000fb30:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'), 
4000fb34:	90 16 23 73 	or  %i0, 0x373, %o0                            
4000fb38:	92 10 20 01 	mov  1, %o1                                    
4000fb3c:	94 10 20 54 	mov  0x54, %o2                                 
4000fb40:	96 10 20 00 	clr  %o3                                       
4000fb44:	7f ff e6 ff 	call  40009740 <rtems_semaphore_create>        
4000fb48:	98 07 20 2c 	add  %i4, 0x2c, %o4                            
                               1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,  
                               &bdbuf_cache.sync_lock);               
  if (sc != RTEMS_SUCCESSFUL)                                         
4000fb4c:	80 a2 20 00 	cmp  %o0, 0                                    
4000fb50:	32 bf ff cd 	bne,a   4000fa84 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000fb54:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'), 
4000fb58:	90 16 23 61 	or  %i0, 0x361, %o0                            
4000fb5c:	92 10 20 00 	clr  %o1                                       
4000fb60:	94 10 20 24 	mov  0x24, %o2                                 
4000fb64:	96 10 20 00 	clr  %o3                                       
4000fb68:	7f ff e6 f6 	call  40009740 <rtems_semaphore_create>        
4000fb6c:	98 07 20 68 	add  %i4, 0x68, %o4                            
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.access_waiters.sema);     
  if (sc != RTEMS_SUCCESSFUL)                                         
4000fb70:	80 a2 20 00 	cmp  %o0, 0                                    
4000fb74:	32 bf ff c4 	bne,a   4000fa84 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000fb78:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'), 
4000fb7c:	90 16 23 74 	or  %i0, 0x374, %o0                            
4000fb80:	92 10 20 00 	clr  %o1                                       
4000fb84:	94 10 20 24 	mov  0x24, %o2                                 
4000fb88:	96 10 20 00 	clr  %o3                                       
4000fb8c:	7f ff e6 ed 	call  40009740 <rtems_semaphore_create>        
4000fb90:	98 07 20 70 	add  %i4, 0x70, %o4                            
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.transfer_waiters.sema);   
  if (sc != RTEMS_SUCCESSFUL)                                         
4000fb94:	80 a2 20 00 	cmp  %o0, 0                                    
4000fb98:	32 bf ff bb 	bne,a   4000fa84 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000fb9c:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
    goto error;                                                       
                                                                      
  sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'), 
4000fba0:	90 16 23 62 	or  %i0, 0x362, %o0                            
4000fba4:	92 10 20 00 	clr  %o1                                       
4000fba8:	94 10 20 24 	mov  0x24, %o2                                 
4000fbac:	96 10 20 00 	clr  %o3                                       
4000fbb0:	7f ff e6 e4 	call  40009740 <rtems_semaphore_create>        
4000fbb4:	98 07 20 78 	add  %i4, 0x78, %o4                            
                               0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
                               &bdbuf_cache.buffer_waiters.sema);     
  if (sc != RTEMS_SUCCESSFUL)                                         
4000fbb8:	80 a2 20 00 	cmp  %o0, 0                                    
4000fbbc:	32 bf ff b2 	bne,a   4000fa84 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000fbc0:	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;                      
4000fbc4:	d0 07 60 20 	ld  [ %i5 + 0x20 ], %o0                        
4000fbc8:	40 00 23 8f 	call  40018a04 <.udiv>                         
4000fbcc:	92 10 00 1b 	mov  %i3, %o1                                  
  bdbuf_cache.max_bds_per_group =                                     
    bdbuf_config.buffer_max / bdbuf_config.buffer_min;                
4000fbd0:	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;                      
4000fbd4:	b0 10 00 08 	mov  %o0, %i0                                  
    goto error;                                                       
                                                                      
  /*                                                                  
   * Compute the various number of elements in the cache.             
   */                                                                 
  bdbuf_cache.buffer_min_count =                                      
4000fbd8:	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;                
4000fbdc:	40 00 23 8a 	call  40018a04 <.udiv>                         
4000fbe0:	90 10 00 1a 	mov  %i2, %o0                                  
4000fbe4:	82 10 00 08 	mov  %o0, %g1                                  
  bdbuf_cache.group_count =                                           
    bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;     
4000fbe8:	90 10 00 18 	mov  %i0, %o0                                  
4000fbec:	92 10 00 01 	mov  %g1, %o1                                  
4000fbf0:	40 00 23 85 	call  40018a04 <.udiv>                         
4000fbf4:	c2 27 20 20 	st  %g1, [ %i4 + 0x20 ]                        
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),              
4000fbf8:	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 =                                           
4000fbfc:	d0 27 20 7c 	st  %o0, [ %i4 + 0x7c ]                        
    bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;     
4000fc00:	b4 10 00 08 	mov  %o0, %i2                                  
                                                                      
  /*                                                                  
   * Allocate the memory for the buffer descriptors.                  
   */                                                                 
  bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),              
4000fc04:	7f ff d5 9b 	call  40005270 <calloc>                        
4000fc08:	90 10 20 38 	mov  0x38, %o0                                 
                            bdbuf_cache.buffer_min_count);            
  if (!bdbuf_cache.bds)                                               
4000fc0c:	80 a2 20 00 	cmp  %o0, 0                                    
4000fc10:	02 bf ff 9c 	be  4000fa80 <rtems_bdbuf_init+0x120>          <== NEVER TAKEN
4000fc14:	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),            
4000fc18:	90 10 20 14 	mov  0x14, %o0                                 
4000fc1c:	7f ff d5 95 	call  40005270 <calloc>                        
4000fc20:	92 10 00 1a 	mov  %i2, %o1                                  
                               bdbuf_cache.group_count);              
  if (!bdbuf_cache.groups)                                            
4000fc24:	80 a2 20 00 	cmp  %o0, 0                                    
4000fc28:	02 bf ff 96 	be  4000fa80 <rtems_bdbuf_init+0x120>          <== NEVER TAKEN
4000fc2c:	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)
4000fc30:	92 10 00 1b 	mov  %i3, %o1                                  
4000fc34:	40 00 23 3a 	call  4001891c <.umul>                         
4000fc38:	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,                 
4000fc3c:	92 10 20 20 	mov  0x20, %o1                                 
                      cache_aligment,                                 
                      bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
4000fc40:	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,                 
4000fc44:	11 10 00 71 	sethi  %hi(0x4001c400), %o0                    
4000fc48:	40 00 07 73 	call  40011a14 <rtems_memalign>                
4000fc4c:	90 12 21 a4 	or  %o0, 0x1a4, %o0	! 4001c5a4 <bdbuf_cache+0x18>
4000fc50:	80 a2 20 00 	cmp  %o0, 0                                    
4000fc54:	32 bf ff 8c 	bne,a   4000fa84 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000fc58:	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,                             
4000fc5c:	f0 07 20 80 	ld  [ %i4 + 0x80 ], %i0                        
         bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;          
4000fc60:	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) ==                        
4000fc64:	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;          
4000fc68:	e8 07 20 18 	ld  [ %i4 + 0x18 ], %l4                        
       b < bdbuf_cache.buffer_min_count;                              
4000fc6c:	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))                          
4000fc70:	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;          
4000fc74:	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,                             
4000fc78:	a6 10 00 18 	mov  %i0, %l3                                  
4000fc7c:	a4 10 20 00 	clr  %l2                                       
4000fc80:	80 a4 80 17 	cmp  %l2, %l7                                  
4000fc84:	02 80 00 13 	be  4000fcd0 <rtems_bdbuf_init+0x370>          
4000fc88:	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;                                               
4000fc8c:	e6 26 a0 28 	st  %l3, [ %i2 + 0x28 ]                        
    bd->buffer = buffer;                                              
4000fc90:	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;                                    
4000fc94:	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;                              
4000fc98:	c2 07 20 48 	ld  [ %i4 + 0x48 ], %g1                        
                                                                      
  the_node->next = tail;                                              
4000fc9c:	e0 26 80 00 	st  %l0, [ %i2 ]                               
  tail->previous = the_node;                                          
4000fca0:	f4 27 20 48 	st  %i2, [ %i4 + 0x48 ]                        
  old_last->next = the_node;                                          
4000fca4:	f4 20 40 00 	st  %i2, [ %g1 ]                               
  the_node->previous = old_last;                                      
4000fca8:	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) ==                        
4000fcac:	40 00 24 02 	call  40018cb4 <.urem>                         
4000fcb0:	92 10 00 15 	mov  %l5, %o1                                  
4000fcb4:	80 a2 00 16 	cmp  %o0, %l6                                  
4000fcb8:	22 80 00 02 	be,a   4000fcc0 <rtems_bdbuf_init+0x360>       
4000fcbc:	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)                  
4000fcc0:	a4 04 a0 01 	inc  %l2                                       
4000fcc4:	b4 06 a0 38 	add  %i2, 0x38, %i2                            
4000fcc8:	10 bf ff ee 	b  4000fc80 <rtems_bdbuf_init+0x320>           
4000fccc:	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;             
4000fcd0:	c4 07 20 20 	ld  [ %i4 + 0x20 ], %g2                        
  }                                                                   
                                                                      
  for (b = 0,                                                         
         group = bdbuf_cache.groups,                                  
         bd = bdbuf_cache.bds;                                        
       b < bdbuf_cache.group_count;                                   
4000fcd4:	f6 07 20 7c 	ld  [ %i4 + 0x7c ], %i3                        
       b++,                                                           
         group++,                                                     
         bd += bdbuf_cache.max_bds_per_group)                         
4000fcd8:	87 28 a0 03 	sll  %g2, 3, %g3                               
4000fcdc:	89 28 a0 06 	sll  %g2, 6, %g4                               
4000fce0:	82 10 20 00 	clr  %g1                                       
4000fce4:	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,                                                         
4000fce8:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000fcec:	02 80 00 07 	be  4000fd08 <rtems_bdbuf_init+0x3a8>          
4000fcf0:	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;                                                
4000fcf4:	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;             
4000fcf8:	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++,                                                     
4000fcfc:	b0 06 20 14 	add  %i0, 0x14, %i0                            
         bd += bdbuf_cache.max_bds_per_group)                         
4000fd00:	10 bf ff fa 	b  4000fce8 <rtems_bdbuf_init+0x388>           
4000fd04:	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'), 
4000fd08:	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;                                 
4000fd0c:	b6 10 20 01 	mov  1, %i3                                    
                                                                      
  sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'), 
4000fd10:	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;                                 
4000fd14:	f6 2f 20 04 	stb  %i3, [ %i4 + 4 ]                          
                                                                      
  sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'), 
4000fd18:	90 12 23 50 	or  %o0, 0x350, %o0                            
4000fd1c:	96 10 20 00 	clr  %o3                                       
4000fd20:	15 10 00 3c 	sethi  %hi(0x4000f000), %o2                    
4000fd24:	98 10 00 1c 	mov  %i4, %o4                                  
4000fd28:	7f ff f9 a6 	call  4000e3c0 <rtems_bdbuf_create_task.constprop.9>
4000fd2c:	94 12 a2 f4 	or  %o2, 0x2f4, %o2                            
                                bdbuf_config.swapout_priority,        
                                RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
                                rtems_bdbuf_swapout_task,             
                                0,                                    
                                &bdbuf_cache.swapout);                
  if (sc != RTEMS_SUCCESSFUL)                                         
4000fd30:	80 a2 20 00 	cmp  %o0, 0                                    
4000fd34:	32 bf ff 54 	bne,a   4000fa84 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000fd38:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
    goto error;                                                       
                                                                      
  if (bdbuf_config.max_read_ahead_blocks > 0)                         
4000fd3c:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
4000fd40:	c2 00 63 d8 	ld  [ %g1 + 0x3d8 ], %g1	! 4001abd8 <rtems_bdbuf_configuration>
4000fd44:	80 a0 60 00 	cmp  %g1, 0                                    
4000fd48:	02 80 00 0d 	be  4000fd7c <rtems_bdbuf_init+0x41c>          
4000fd4c:	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'),
4000fd50:	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;                            
4000fd54:	f6 2f 20 94 	stb  %i3, [ %i4 + 0x94 ]                       
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
4000fd58:	15 10 00 3e 	sethi  %hi(0x4000f800), %o2                    
4000fd5c:	90 12 20 41 	or  %o0, 0x41, %o0                             
4000fd60:	94 12 a0 0c 	or  %o2, 0xc, %o2                              
4000fd64:	96 10 20 00 	clr  %o3                                       
4000fd68:	7f ff f9 96 	call  4000e3c0 <rtems_bdbuf_create_task.constprop.9>
4000fd6c:	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)                                       
4000fd70:	80 a2 20 00 	cmp  %o0, 0                                    
4000fd74:	32 bf ff 44 	bne,a   4000fa84 <rtems_bdbuf_init+0x124>      <== NEVER TAKEN
4000fd78:	d0 07 20 84 	ld  [ %i4 + 0x84 ], %o0                        <== NOT EXECUTED
      goto error;                                                     
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000fd7c:	7f ff f8 a0 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000fd80:	b0 10 20 00 	clr  %i0                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000fd84:	81 c7 e0 08 	ret                                            
4000fd88:	81 e8 00 00 	restore                                        
                                                                      

4000df70 <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) {
4000df70:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = rtems_semaphore_obtain (lock,                
4000df74:	92 10 20 00 	clr  %o1                                       
4000df78:	90 10 00 18 	mov  %i0, %o0                                  
4000df7c:	7f ff ee 99 	call  400099e0 <rtems_semaphore_obtain>        
4000df80:	94 10 20 00 	clr  %o2                                       
                                                 RTEMS_WAIT,          
                                                 RTEMS_NO_TIMEOUT);   
  if (sc != RTEMS_SUCCESSFUL)                                         
4000df84:	80 a2 20 00 	cmp  %o0, 0                                    
4000df88:	12 80 00 04 	bne  4000df98 <rtems_bdbuf_lock+0x28>          <== NEVER TAKEN
4000df8c:	01 00 00 00 	nop                                            
4000df90:	81 c7 e0 08 	ret                                            
4000df94:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (fatal_error_code);                             
4000df98:	7f ff ff f1 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000df9c:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
                                                                      

400103a4 <rtems_bdbuf_purge_dev>: } } void rtems_bdbuf_purge_dev (rtems_disk_device *dd) {
400103a4:	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;                                                  
400103a8:	b4 07 bf 74 	add  %fp, -140, %i2                            
400103ac:	b6 07 bf 78 	add  %fp, -136, %i3                            
  head->previous = NULL;                                              
400103b0:	c0 27 bf 78 	clr  [ %fp + -136 ]                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
400103b4:	f6 27 bf 74 	st  %i3, [ %fp + -140 ]                        
  rtems_chain_control purge_list;                                     
                                                                      
  rtems_chain_initialize_empty (&purge_list);                         
  rtems_bdbuf_lock_cache ();                                          
400103b8:	7f ff f6 fb 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
400103bc:	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);            
400103c0:	c2 06 20 64 	ld  [ %i0 + 0x64 ], %g1                        
400103c4:	80 a0 60 00 	cmp  %g1, 0                                    
400103c8:	02 80 00 70 	be  40010588 <rtems_bdbuf_purge_dev+0x1e4>     <== ALWAYS TAKEN
400103cc:	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;                                          
400103d0:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
400103d4:	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;                                 
400103d8:	c0 26 20 68 	clr  [ %i0 + 0x68 ]                            <== NOT EXECUTED
400103dc:	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;                         
400103e0:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    <== NOT EXECUTED
400103e4:	82 10 61 8c 	or  %g1, 0x18c, %g1	! 4001c58c <bdbuf_cache>   
400103e8:	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;          
400103ec:	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;                                                       
400103f0:	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;          
400103f4:	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)                                                 
400103f8:	80 a7 60 00 	cmp  %i5, 0                                    
400103fc:	02 80 00 2e 	be  400104b4 <rtems_bdbuf_purge_dev+0x110>     
40010400:	b8 07 bf 80 	add  %fp, -128, %i4                            
  {                                                                   
    if (cur->dd == dd)                                                
    {                                                                 
      switch (cur->state)                                             
40010404:	33 10 00 37 	sethi  %hi(0x4000dc00), %i1                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
40010408:	a2 10 20 06 	mov  6, %l1                                    
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if (cur->dd == dd)                                                
    {                                                                 
      switch (cur->state)                                             
4001040c:	b2 16 61 ac 	or  %i1, 0x1ac, %i1                            
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
40010410:	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);           
40010414:	10 80 00 09 	b  40010438 <rtems_bdbuf_purge_dev+0x94>       
40010418:	a0 00 60 6c 	add  %g1, 0x6c, %l0                            
        default:                                                      
          rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_STATE_11);             
      }                                                               
    }                                                                 
                                                                      
    if (cur->avl.left != NULL)                                        
4001041c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40010420:	80 a0 60 00 	cmp  %g1, 0                                    
40010424:	22 80 00 0f 	be,a   40010460 <rtems_bdbuf_purge_dev+0xbc>   
40010428:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    }                                                                 
    else if (cur->avl.right != NULL)                                  
    {                                                                 
      /* Right */                                                     
      ++prev;                                                         
      *prev = cur;                                                    
4001042c:	fa 27 20 04 	st  %i5, [ %i4 + 4 ]                           
40010430:	ba 10 00 01 	mov  %g1, %i5                                  
      cur = cur->avl.left;                                            
    }                                                                 
    else if (cur->avl.right != NULL)                                  
    {                                                                 
      /* Right */                                                     
      ++prev;                                                         
40010434:	b8 07 20 04 	add  %i4, 4, %i4                               
                                                                      
  *prev = NULL;                                                       
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if (cur->dd == dd)                                                
40010438:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4001043c:	80 a6 00 01 	cmp  %i0, %g1                                  
40010440:	32 bf ff f8 	bne,a   40010420 <rtems_bdbuf_purge_dev+0x7c>  
40010444:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
    {                                                                 
      switch (cur->state)                                             
40010448:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
4001044c:	80 a0 60 0a 	cmp  %g1, 0xa                                  
40010450:	28 80 00 34 	bleu,a   40010520 <rtems_bdbuf_purge_dev+0x17c><== ALWAYS TAKEN
40010454:	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);             
40010458:	7f ff f6 c1 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4001045c:	90 10 20 17 	mov  0x17, %o0                                 <== NOT EXECUTED
      /* Left */                                                      
      ++prev;                                                         
      *prev = cur;                                                    
      cur = cur->avl.left;                                            
    }                                                                 
    else if (cur->avl.right != NULL)                                  
40010460:	80 a0 60 00 	cmp  %g1, 0                                    
40010464:	32 bf ff f3 	bne,a   40010430 <rtems_bdbuf_purge_dev+0x8c>  
40010468:	fa 27 20 04 	st  %i5, [ %i4 + 4 ]                           
      *prev = cur;                                                    
      cur = cur->avl.right;                                           
    }                                                                 
    else                                                              
    {                                                                 
      while (*prev != NULL                                            
4001046c:	c2 07 00 00 	ld  [ %i4 ], %g1                               
40010470:	80 a0 60 00 	cmp  %g1, 0                                    
40010474:	32 80 00 06 	bne,a   4001048c <rtems_bdbuf_purge_dev+0xe8>  
40010478:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4001047c:	10 80 00 0f 	b  400104b8 <rtems_bdbuf_purge_dev+0x114>      
40010480:	d0 07 bf 74 	ld  [ %fp + -140 ], %o0                        
40010484:	82 10 00 02 	mov  %g2, %g1                                  
             && (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
40010488:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
4001048c:	80 a0 80 1d 	cmp  %g2, %i5                                  
40010490:	02 80 00 04 	be  400104a0 <rtems_bdbuf_purge_dev+0xfc>      
40010494:	80 a0 a0 00 	cmp  %g2, 0                                    
40010498:	32 bf ff e8 	bne,a   40010438 <rtems_bdbuf_purge_dev+0x94>  
4001049c:	ba 10 00 02 	mov  %g2, %i5                                  
      {                                                               
        /* Up */                                                      
        cur = *prev;                                                  
        --prev;                                                       
400104a0:	b8 07 3f fc 	add  %i4, -4, %i4                              
      *prev = cur;                                                    
      cur = cur->avl.right;                                           
    }                                                                 
    else                                                              
    {                                                                 
      while (*prev != NULL                                            
400104a4:	c4 07 00 00 	ld  [ %i4 ], %g2                               
400104a8:	80 a0 a0 00 	cmp  %g2, 0                                    
400104ac:	12 bf ff f6 	bne  40010484 <rtems_bdbuf_purge_dev+0xe0>     
400104b0:	ba 10 00 01 	mov  %g1, %i5                                  
400104b4:	d0 07 bf 74 	ld  [ %fp + -140 ], %o0                        
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)              
{                                                                     
  bool wake_buffer_waiters = false;                                   
400104b8:	86 10 20 00 	clr  %g3                                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
400104bc:	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))                                   
400104c0:	80 a2 00 1b 	cmp  %o0, %i3                                  
400104c4:	02 80 00 0f 	be  40010500 <rtems_bdbuf_purge_dev+0x15c>     
400104c8:	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;                            
400104cc:	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)                                             
400104d0:	c4 02 20 24 	ld  [ %o0 + 0x24 ], %g2                        
                                                                      
  head->next = new_first;                                             
400104d4:	c2 27 bf 74 	st  %g1, [ %fp + -140 ]                        
400104d8:	80 a0 a0 00 	cmp  %g2, 0                                    
400104dc:	12 80 00 28 	bne  4001057c <rtems_bdbuf_purge_dev+0x1d8>    
400104e0:	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;                                                  
400104e4:	7f ff f8 ca 	call  4000e80c <rtems_bdbuf_discard_buffer.part.4>
400104e8:	fa 22 20 20 	st  %i5, [ %o0 + 0x20 ]                        
400104ec:	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))                                   
400104f0:	80 a2 00 1b 	cmp  %o0, %i3                                  
400104f4:	12 bf ff f6 	bne  400104cc <rtems_bdbuf_purge_dev+0x128>    
400104f8:	86 10 20 01 	mov  1, %g3                                    
      wake_buffer_waiters = true;                                     
                                                                      
    rtems_bdbuf_discard_buffer (bd);                                  
  }                                                                   
                                                                      
  if (wake_buffer_waiters)                                            
400104fc:	80 88 e0 ff 	btst  0xff, %g3                                
40010500:	02 80 00 04 	be  40010510 <rtems_bdbuf_purge_dev+0x16c>     
40010504:	11 10 00 71 	sethi  %hi(0x4001c400), %o0                    
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
40010508:	7f ff f7 5e 	call  4000e280 <rtems_bdbuf_wake>              
4001050c:	90 12 22 00 	or  %o0, 0x200, %o0	! 4001c600 <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 ();                                        
40010510:	7f ff f6 bb 	call  4000dffc <rtems_bdbuf_unlock_cache>      
40010514:	01 00 00 00 	nop                                            
40010518:	81 c7 e0 08 	ret                                            
4001051c:	81 e8 00 00 	restore                                        
                                                                      
  while (cur != NULL)                                                 
  {                                                                   
    if (cur->dd == dd)                                                
    {                                                                 
      switch (cur->state)                                             
40010520:	c4 06 40 01 	ld  [ %i1 + %g1 ], %g2                         
40010524:	81 c0 80 00 	jmp  %g2                                       
40010528:	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);           
4001052c:	7f ff f7 55 	call  4000e280 <rtems_bdbuf_wake>              
40010530:	90 10 00 10 	mov  %l0, %o0                                  
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
40010534:	c4 07 60 28 	ld  [ %i5 + 0x28 ], %g2                        
40010538:	c2 00 a0 0c 	ld  [ %g2 + 0xc ], %g1                         
4001053c:	82 00 7f ff 	add  %g1, -1, %g1                              
40010540:	c2 20 a0 0c 	st  %g1, [ %g2 + 0xc ]                         
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
40010544:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
40010548:	c6 07 40 00 	ld  [ %i5 ], %g3                               
  previous       = the_node->previous;                                
  next->previous = previous;                                          
4001054c:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
40010550:	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;                              
40010554:	c4 07 bf 7c 	ld  [ %fp + -132 ], %g2                        
                                                                      
  the_node->next = tail;                                              
40010558:	f6 27 40 00 	st  %i3, [ %i5 ]                               
  tail->previous = the_node;                                          
4001055c:	fa 27 bf 7c 	st  %i5, [ %fp + -132 ]                        
  old_last->next = the_node;                                          
40010560:	fa 20 80 00 	st  %i5, [ %g2 ]                               
  the_node->previous = old_last;                                      
40010564:	10 bf ff ae 	b  4001041c <rtems_bdbuf_purge_dev+0x78>       
40010568:	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;                                                  
4001056c:	10 bf ff ac 	b  4001041c <rtems_bdbuf_purge_dev+0x78>       
40010570:	e2 27 60 20 	st  %l1, [ %i5 + 0x20 ]                        
40010574:	10 bf ff aa 	b  4001041c <rtems_bdbuf_purge_dev+0x78>       
40010578:	e4 27 60 20 	st  %l2, [ %i5 + 0x20 ]                        
4001057c:	fa 22 20 20 	st  %i5, [ %o0 + 0x20 ]                        
40010580:	10 bf ff d0 	b  400104c0 <rtems_bdbuf_purge_dev+0x11c>      
40010584:	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);            
40010588:	80 a0 a0 00 	cmp  %g2, 0                                    
4001058c:	32 bf ff 92 	bne,a   400103d4 <rtems_bdbuf_purge_dev+0x30>  <== NEVER TAKEN
40010590:	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;                         
40010594:	10 bf ff 94 	b  400103e4 <rtems_bdbuf_purge_dev+0x40>       
40010598:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
                                                                      

4000fe8c <rtems_bdbuf_read>: rtems_status_code rtems_bdbuf_read (rtems_disk_device *dd, rtems_blkdev_bnum block, rtems_bdbuf_buffer **bd_ptr) {
4000fe8c:	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 ();                                          
4000fe90:	7f ff f8 45 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
4000fe94:	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)                                        
4000fe98:	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;                                    
4000fe9c:	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)                                        
4000fea0:	80 a6 40 01 	cmp  %i1, %g1                                  
4000fea4:	0a 80 00 07 	bcs  4000fec0 <rtems_bdbuf_read+0x34>          <== ALWAYS TAKEN
4000fea8:	b0 10 20 04 	mov  4, %i0                                    
    }                                                                 
                                                                      
    rtems_bdbuf_check_read_ahead_trigger (dd, block);                 
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4000feac:	7f ff f8 54 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000feb0:	01 00 00 00 	nop                                            
                                                                      
  *bd_ptr = bd;                                                       
4000feb4:	f8 26 80 00 	st  %i4, [ %i2 ]                               
4000feb8:	81 c7 e0 08 	ret                                            
4000febc:	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)                            
4000fec0:	d2 07 60 30 	ld  [ %i5 + 0x30 ], %o1                        
4000fec4:	80 a2 60 00 	cmp  %o1, 0                                    
4000fec8:	26 80 00 60 	bl,a   40010048 <rtems_bdbuf_read+0x1bc>       <== NEVER TAKEN
4000fecc:	d6 07 60 24 	ld  [ %i5 + 0x24 ], %o3                        <== NOT EXECUTED
    return block << dd->block_to_media_block_shift;                   
4000fed0:	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;
4000fed4:	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);         
4000fed8:	90 10 00 1d 	mov  %i5, %o0                                  
4000fedc:	7f ff fb 9e 	call  4000ed54 <rtems_bdbuf_get_buffer_for_access>
4000fee0:	92 02 40 01 	add  %o1, %g1, %o1                             
4000fee4:	b8 10 00 08 	mov  %o0, %i4                                  
    switch (bd->state)                                                
4000fee8:	d0 02 20 20 	ld  [ %o0 + 0x20 ], %o0                        
4000feec:	80 a2 20 02 	cmp  %o0, 2                                    
4000fef0:	02 80 00 4f 	be  4001002c <rtems_bdbuf_read+0x1a0>          
4000fef4:	80 a2 20 07 	cmp  %o0, 7                                    
4000fef8:	02 80 00 06 	be  4000ff10 <rtems_bdbuf_read+0x84>           
4000fefc:	80 a2 20 01 	cmp  %o0, 1                                    
4000ff00:	22 80 00 28 	be,a   4000ffa0 <rtems_bdbuf_read+0x114>       <== ALWAYS TAKEN
4000ff04:	c4 07 60 48 	ld  [ %i5 + 0x48 ], %g2                        
        {                                                             
          bd = NULL;                                                  
        }                                                             
        break;                                                        
      default:                                                        
        rtems_bdbuf_fatal_with_state (bd->state, RTEMS_BDBUF_FATAL_STATE_4);
4000ff08:	7f ff f8 2d 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000ff0c:	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;                                        
4000ff10:	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;                                                  
4000ff14:	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;                                        
4000ff18:	82 00 60 01 	inc  %g1                                       
4000ff1c:	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;                                                  
4000ff20:	82 10 20 04 	mov  4, %g1                                    
4000ff24:	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                                
4000ff28:	37 10 00 71 	sethi  %hi(0x4001c400), %i3                    
4000ff2c:	b6 16 e1 8c 	or  %i3, 0x18c, %i3	! 4001c58c <bdbuf_cache>   
4000ff30:	d0 06 e0 84 	ld  [ %i3 + 0x84 ], %o0                        
4000ff34:	80 a2 20 00 	cmp  %o0, 0                                    
4000ff38:	02 bf ff dd 	be  4000feac <rtems_bdbuf_read+0x20>           
4000ff3c:	01 00 00 00 	nop                                            
      && dd->read_ahead.trigger == block                              
4000ff40:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1                        
4000ff44:	80 a6 40 01 	cmp  %i1, %g1                                  
4000ff48:	12 bf ff d9 	bne  4000feac <rtems_bdbuf_read+0x20>          
4000ff4c:	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);            
4000ff50:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
4000ff54:	80 a0 60 00 	cmp  %g1, 0                                    
4000ff58:	12 bf ff d5 	bne  4000feac <rtems_bdbuf_read+0x20>          <== NEVER TAKEN
4000ff5c:	01 00 00 00 	nop                                            
4000ff60:	c2 07 60 68 	ld  [ %i5 + 0x68 ], %g1                        
4000ff64:	80 a0 60 00 	cmp  %g1, 0                                    
4000ff68:	12 bf ff d1 	bne  4000feac <rtems_bdbuf_read+0x20>          <== NEVER TAKEN
4000ff6c:	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))                                 
4000ff70:	c2 06 e0 88 	ld  [ %i3 + 0x88 ], %g1                        
4000ff74:	b2 06 e0 8c 	add  %i3, 0x8c, %i1                            
4000ff78:	80 a0 40 19 	cmp  %g1, %i1                                  
4000ff7c:	02 80 00 41 	be  40010080 <rtems_bdbuf_read+0x1f4>          <== ALWAYS TAKEN
4000ff80:	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;                              
4000ff84:	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);     
4000ff88:	84 07 60 64 	add  %i5, 0x64, %g2                            
                                                                      
  the_node->next = tail;                                              
4000ff8c:	f2 27 60 64 	st  %i1, [ %i5 + 0x64 ]                        
  tail->previous = the_node;                                          
4000ff90:	c4 26 e0 90 	st  %g2, [ %i3 + 0x90 ]                        
  old_last->next = the_node;                                          
4000ff94:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  the_node->previous = old_last;                                      
4000ff98:	10 bf ff c5 	b  4000feac <rtems_bdbuf_read+0x20>            
4000ff9c:	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)                                
4000ffa0:	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;                                      
4000ffa4:	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)                                
4000ffa8:	80 a6 40 01 	cmp  %i1, %g1                                  
4000ffac:	02 80 00 0e 	be  4000ffe4 <rtems_bdbuf_read+0x158>          
4000ffb0:	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);            
4000ffb4:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
4000ffb8:	80 a0 60 00 	cmp  %g1, 0                                    
4000ffbc:	02 80 00 2c 	be  4001006c <rtems_bdbuf_read+0x1e0>          <== ALWAYS TAKEN
4000ffc0:	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;                                          
4000ffc4:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           <== NOT EXECUTED
  previous->next = next;                                              
4000ffc8:	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;                                 
4000ffcc:	c0 27 60 68 	clr  [ %i5 + 0x68 ]                            <== NOT EXECUTED
4000ffd0:	c0 27 60 64 	clr  [ %i5 + 0x64 ]                            <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_read_ahead_cancel (dd);                               
    dd->read_ahead.trigger = block + 1;                               
4000ffd4:	84 06 60 01 	add  %i1, 1, %g2                               <== NOT EXECUTED
    dd->read_ahead.next = block + 2;                                  
4000ffd8:	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;                               
4000ffdc:	c4 27 60 6c 	st  %g2, [ %i5 + 0x6c ]                        
    dd->read_ahead.next = block + 2;                                  
4000ffe0:	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);            
4000ffe4:	90 10 00 1d 	mov  %i5, %o0                                  
4000ffe8:	92 10 00 1c 	mov  %i4, %o1                                  
4000ffec:	7f ff fd cc 	call  4000f71c <rtems_bdbuf_execute_read_request>
4000fff0:	94 10 20 01 	mov  1, %o2                                    
        if (sc == RTEMS_SUCCESSFUL)                                   
4000fff4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000fff8:	32 bf ff cc 	bne,a   4000ff28 <rtems_bdbuf_read+0x9c>       
4000fffc:	b8 10 20 00 	clr  %i4                                       
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
40010000:	c2 07 20 28 	ld  [ %i4 + 0x28 ], %g1                        
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
  previous       = the_node->previous;                                
40010004:	c4 07 20 04 	ld  [ %i4 + 4 ], %g2                           
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
40010008:	c6 07 00 00 	ld  [ %i4 ], %g3                               
4001000c:	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;                                                  
40010010:	b6 10 20 03 	mov  3, %i3                                    
40010014:	f6 27 20 20 	st  %i3, [ %i4 + 0x20 ]                        
  previous       = the_node->previous;                                
  next->previous = previous;                                          
40010018:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
4001001c:	c6 20 80 00 	st  %g3, [ %g2 ]                               
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)                     
{                                                                     
  ++bd->group->users;                                                 
40010020:	84 01 20 01 	add  %g4, 1, %g2                               
40010024:	10 bf ff c1 	b  4000ff28 <rtems_bdbuf_read+0x9c>            
40010028:	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;                                        
4001002c:	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;                                                  
40010030:	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;                                        
40010034:	82 00 60 01 	inc  %g1                                       
40010038:	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;                                                  
4001003c:	82 10 20 03 	mov  3, %g1                                    
40010040:	10 bf ff ba 	b  4000ff28 <rtems_bdbuf_read+0x9c>            
40010044:	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); 
40010048:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4001004c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40010050:	40 00 23 c5 	call  40018f64 <__muldi3>                      <== NOT EXECUTED
40010054:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40010058:	d6 07 60 20 	ld  [ %i5 + 0x20 ], %o3                        <== NOT EXECUTED
4001005c:	40 00 25 d3 	call  400197a8 <__udivdi3>                     <== NOT EXECUTED
40010060:	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;
40010064:	10 bf ff 9d 	b  4000fed8 <rtems_bdbuf_read+0x4c>            <== NOT EXECUTED
40010068:	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);            
4001006c:	80 a0 a0 00 	cmp  %g2, 0                                    
40010070:	32 bf ff d5 	bne,a   4000ffc4 <rtems_bdbuf_read+0x138>      <== NEVER TAKEN
40010074:	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;                               
40010078:	10 bf ff d8 	b  4000ffd8 <rtems_bdbuf_read+0x14c>           
4001007c:	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,             
40010080:	7f ff e5 1f 	call  400094fc <rtems_event_send>              
40010084:	92 10 20 02 	mov  2, %o1                                    
                             RTEMS_BDBUF_READ_AHEAD_WAKE_UP);         
      if (sc != RTEMS_SUCCESSFUL)                                     
40010088:	80 a2 20 00 	cmp  %o0, 0                                    
4001008c:	22 bf ff bf 	be,a   4000ff88 <rtems_bdbuf_read+0xfc>        <== ALWAYS TAKEN
40010090:	c2 06 e0 90 	ld  [ %i3 + 0x90 ], %g1                        
        rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_RA_WAKE_UP);             
40010094:	7f ff f7 b2 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
40010098:	90 10 20 07 	mov  7, %o0                                    <== NOT EXECUTED
                                                                      

4000f80c <rtems_bdbuf_read_ahead_task>: return sc; } static rtems_task rtems_bdbuf_read_ahead_task (rtems_task_argument arg) {
4000f80c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;         
                                                                      
  while (bdbuf_cache.read_ahead_enabled)                              
4000f810:	37 10 00 71 	sethi  %hi(0x4001c400), %i3                    
4000f814:	b6 16 e1 8c 	or  %i3, 0x18c, %i3	! 4001c58c <bdbuf_cache>   
4000f818:	c2 0e e0 94 	ldub  [ %i3 + 0x94 ], %g1                      
4000f81c:	80 a0 60 00 	cmp  %g1, 0                                    
4000f820:	02 80 00 22 	be  4000f8a8 <rtems_bdbuf_read_ahead_task+0x9c><== NEVER TAKEN
4000f824:	b0 06 e0 88 	add  %i3, 0x88, %i0                            
4000f828:	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;                    
4000f82c:	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;
4000f830:	23 10 00 6a 	sethi  %hi(0x4001a800), %l1                    
                                                                      
  while (bdbuf_cache.read_ahead_enabled)                              
  {                                                                   
    rtems_chain_node *node;                                           
                                                                      
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);      
4000f834:	7f ff fa 53 	call  4000e180 <rtems_bdbuf_wait_for_event>    
4000f838:	90 10 20 02 	mov  2, %o0                                    
    rtems_bdbuf_lock_cache ();                                        
4000f83c:	7f ff f9 da 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
4000f840:	01 00 00 00 	nop                                            
4000f844:	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))                                   
4000f848:	80 a7 40 19 	cmp  %i5, %i1                                  
4000f84c:	02 80 00 11 	be  4000f890 <rtems_bdbuf_read_ahead_task+0x84>
4000f850:	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;                            
4000f854:	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;                  
4000f858:	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)                                        
4000f85c:	c4 07 7f c4 	ld  [ %i5 + -60 ], %g2                         
                                                                      
  head->next = new_first;                                             
4000f860:	c2 26 a0 88 	st  %g1, [ %i2 + 0x88 ]                        
4000f864:	80 a7 00 02 	cmp  %i4, %g2                                  
4000f868:	0a 80 00 12 	bcs  4000f8b0 <rtems_bdbuf_read_ahead_task+0xa4>
4000f86c:	f0 20 60 04 	st  %i0, [ %g1 + 4 ]                           
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
4000f870:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
4000f874:	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;    
4000f878:	82 10 3f ff 	mov  -1, %g1                                   
4000f87c:	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;                    
4000f880:	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))                                   
4000f884:	80 a7 40 19 	cmp  %i5, %i1                                  
4000f888:	32 bf ff f4 	bne,a   4000f858 <rtems_bdbuf_read_ahead_task+0x4c><== NEVER TAKEN
4000f88c:	c2 07 40 00 	ld  [ %i5 ], %g1                               <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
4000f890:	7f ff f9 db 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000f894:	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)                              
4000f898:	c2 0e a0 94 	ldub  [ %i2 + 0x94 ], %g1                      
4000f89c:	80 a0 60 00 	cmp  %g1, 0                                    
4000f8a0:	12 bf ff e5 	bne  4000f834 <rtems_bdbuf_read_ahead_task+0x28><== ALWAYS TAKEN
4000f8a4:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
  }                                                                   
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
4000f8a8:	7f ff e9 26 	call  40009d40 <rtems_task_delete>             <== NOT EXECUTED
4000f8ac:	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)                            
4000f8b0:	d2 07 7f cc 	ld  [ %i5 + -52 ], %o1                         
4000f8b4:	80 a2 60 00 	cmp  %o1, 0                                    
4000f8b8:	26 80 00 21 	bl,a   4000f93c <rtems_bdbuf_read_ahead_task+0x130><== NEVER TAKEN
4000f8bc:	d2 07 7f c0 	ld  [ %i5 + -64 ], %o1                         <== NOT EXECUTED
    return block << dd->block_to_media_block_shift;                   
4000f8c0:	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;
4000f8c4:	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 *)                   
4000f8c8:	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 =                                      
4000f8cc:	92 02 40 01 	add  %o1, %g1, %o1                             
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
4000f8d0:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
4000f8d4:	c0 27 40 00 	clr  [ %i5 ]                                   
4000f8d8:	7f ff fd 08 	call  4000ecf8 <rtems_bdbuf_get_buffer_for_read_ahead>
4000f8dc:	90 10 00 10 	mov  %l0, %o0                                  
          rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);    
                                                                      
        if (bd != NULL)                                               
4000f8e0:	92 92 20 00 	orcc  %o0, 0, %o1                              
4000f8e4:	02 bf ff d8 	be  4000f844 <rtems_bdbuf_read_ahead_task+0x38><== NEVER TAKEN
4000f8e8:	c2 04 63 d8 	ld  [ %l1 + 0x3d8 ], %g1                       
        {                                                             
          uint32_t transfer_count = dd->block_count - block;          
4000f8ec:	d4 07 7f c4 	ld  [ %i5 + -60 ], %o2                         
4000f8f0:	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)                   
4000f8f4:	80 a2 80 01 	cmp  %o2, %g1                                  
4000f8f8:	2a 80 00 0f 	bcs,a   4000f934 <rtems_bdbuf_read_ahead_task+0x128>
4000f8fc:	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;             
4000f900:	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;      
4000f904:	87 30 60 01 	srl  %g1, 1, %g3                               
            dd->read_ahead.next = block + transfer_count;             
4000f908:	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;      
4000f90c:	b8 00 c0 1c 	add  %g3, %i4, %i4                             
            dd->read_ahead.next = block + transfer_count;             
4000f910:	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;      
4000f914:	f8 27 60 08 	st  %i4, [ %i5 + 8 ]                           
          else                                                        
          {                                                           
            dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
          }                                                           
                                                                      
          ++dd->stats.read_ahead_transfers;                           
4000f918:	c2 07 7f e8 	ld  [ %i5 + -24 ], %g1                         
          rtems_bdbuf_execute_read_request (dd, bd, transfer_count);  
4000f91c:	90 10 00 10 	mov  %l0, %o0                                  
          else                                                        
          {                                                           
            dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
          }                                                           
                                                                      
          ++dd->stats.read_ahead_transfers;                           
4000f920:	82 00 60 01 	inc  %g1                                       
          rtems_bdbuf_execute_read_request (dd, bd, transfer_count);  
4000f924:	7f ff ff 7e 	call  4000f71c <rtems_bdbuf_execute_read_request>
4000f928:	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;                    
4000f92c:	10 bf ff c7 	b  4000f848 <rtems_bdbuf_read_ahead_task+0x3c> 
4000f930:	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;
4000f934:	10 bf ff f9 	b  4000f918 <rtems_bdbuf_read_ahead_task+0x10c>
4000f938:	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); 
4000f93c:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4000f940:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000f944:	40 00 25 88 	call  40018f64 <__muldi3>                      <== NOT EXECUTED
4000f948:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4000f94c:	d6 07 7f bc 	ld  [ %i5 + -68 ], %o3                         <== NOT EXECUTED
4000f950:	40 00 27 96 	call  400197a8 <__udivdi3>                     <== NOT EXECUTED
4000f954:	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;
4000f958:	10 bf ff dc 	b  4000f8c8 <rtems_bdbuf_read_ahead_task+0xbc> <== NOT EXECUTED
4000f95c:	c2 07 7f b4 	ld  [ %i5 + -76 ], %g1                         <== NOT EXECUTED
                                                                      

400100a0 <rtems_bdbuf_release>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_bdbuf_release (rtems_bdbuf_buffer *bd) {
400100a0:	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)                                                     
400100a4:	80 a6 20 00 	cmp  %i0, 0                                    
400100a8:	02 80 00 0f 	be  400100e4 <rtems_bdbuf_release+0x44>        <== NEVER TAKEN
400100ac:	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();                                           
400100b0:	7f ff f7 bd 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
400100b4:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");           
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
400100b8:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
400100bc:	80 a2 20 04 	cmp  %o0, 4                                    
400100c0:	02 80 00 14 	be  40010110 <rtems_bdbuf_release+0x70>        
400100c4:	01 00 00 00 	nop                                            
400100c8:	18 80 00 09 	bgu  400100ec <rtems_bdbuf_release+0x4c>       
400100cc:	80 a2 20 06 	cmp  %o0, 6                                    
400100d0:	80 a2 20 03 	cmp  %o0, 3                                    
400100d4:	22 80 00 15 	be,a   40010128 <rtems_bdbuf_release+0x88>     <== ALWAYS TAKEN
400100d8:	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);
400100dc:	7f ff f7 b8 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
400100e0:	92 10 20 0e 	mov  0xe, %o1                                  <== NOT EXECUTED
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400100e4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400100e8:	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)                                                  
400100ec:	18 bf ff fc 	bgu  400100dc <rtems_bdbuf_release+0x3c>       <== NEVER TAKEN
400100f0:	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);                   
400100f4:	90 10 00 18 	mov  %i0, %o0                                  
400100f8:	7f ff f9 d2 	call  4000e840 <rtems_bdbuf_discard_buffer_after_access>
400100fc:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
40010100:	7f ff f7 bf 	call  4000dffc <rtems_bdbuf_unlock_cache>      
40010104:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40010108:	81 c7 e0 08 	ret                                            
4001010c:	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);             
40010110:	7f ff f8 6b 	call  4000e2bc <rtems_bdbuf_add_to_modified_list_after_access>
40010114:	90 10 00 18 	mov  %i0, %o0                                  
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
40010118:	7f ff f7 b9 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4001011c:	b0 10 20 00 	clr  %i0                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40010120:	81 c7 e0 08 	ret                                            
40010124:	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;                              
40010128:	11 10 00 71 	sethi  %hi(0x4001c400), %o0                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)                    
{                                                                     
  --bd->group->users;                                                 
4001012c:	c4 00 60 0c 	ld  [ %g1 + 0xc ], %g2                         
40010130:	90 12 21 8c 	or  %o0, 0x18c, %o0                            
40010134:	84 00 bf ff 	add  %g2, -1, %g2                              
40010138:	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;                                                  
4001013c:	82 10 20 02 	mov  2, %g1                                    
                                                                      
  the_node->next = tail;                                              
40010140:	84 02 20 44 	add  %o0, 0x44, %g2                            
40010144:	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;                              
40010148:	c2 02 20 48 	ld  [ %o0 + 0x48 ], %g1                        
                                                                      
  the_node->next = tail;                                              
4001014c:	c4 26 00 00 	st  %g2, [ %i0 ]                               
  tail->previous = the_node;                                          
40010150:	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)                                                    
40010154:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
40010158:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
4001015c:	80 a0 a0 00 	cmp  %g2, 0                                    
40010160:	12 80 00 05 	bne  40010174 <rtems_bdbuf_release+0xd4>       
40010164:	f0 20 40 00 	st  %i0, [ %g1 ]                               
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
  else                                                                
    rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);                   
40010168:	7f ff f8 46 	call  4000e280 <rtems_bdbuf_wake>              
4001016c:	90 02 20 74 	add  %o0, 0x74, %o0                            
40010170:	30 bf ff ea 	b,a   40010118 <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);                   
40010174:	7f ff f8 43 	call  4000e280 <rtems_bdbuf_wake>              
40010178:	90 02 20 64 	add  %o0, 0x64, %o0                            
4001017c:	30 bf ff e7 	b,a   40010118 <rtems_bdbuf_release+0x78>      
                                                                      

40010180 <rtems_bdbuf_release_modified>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd) {
40010180:	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)                                                     
40010184:	80 a6 20 00 	cmp  %i0, 0                                    
40010188:	02 80 00 13 	be  400101d4 <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
4001018c:	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();                                           
40010190:	7f ff f7 85 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
40010194:	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)                                                  
40010198:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4001019c:	80 a2 20 03 	cmp  %o0, 3                                    
400101a0:	1a 80 00 04 	bcc  400101b0 <rtems_bdbuf_release_modified+0x30><== ALWAYS TAKEN
400101a4:	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);
400101a8:	7f ff f7 85 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
400101ac:	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)                                                  
400101b0:	18 80 00 0b 	bgu  400101dc <rtems_bdbuf_release_modified+0x5c>
400101b4:	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);             
400101b8:	90 10 00 18 	mov  %i0, %o0                                  
400101bc:	7f ff f8 40 	call  4000e2bc <rtems_bdbuf_add_to_modified_list_after_access>
400101c0:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
400101c4:	7f ff f7 8e 	call  4000dffc <rtems_bdbuf_unlock_cache>      
400101c8:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
400101cc:	81 c7 e0 08 	ret                                            
400101d0:	81 e8 00 00 	restore                                        
}                                                                     
400101d4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400101d8:	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)                                                  
400101dc:	12 bf ff f3 	bne  400101a8 <rtems_bdbuf_release_modified+0x28><== NEVER TAKEN
400101e0:	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);                   
400101e4:	90 10 00 18 	mov  %i0, %o0                                  
400101e8:	7f ff f9 96 	call  4000e840 <rtems_bdbuf_discard_buffer_after_access>
400101ec:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
400101f0:	7f ff f7 83 	call  4000dffc <rtems_bdbuf_unlock_cache>      
400101f4:	01 00 00 00 	nop                                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
400101f8:	81 c7 e0 08 	ret                                            
400101fc:	81 e8 00 00 	restore                                        
                                                                      

4000e420 <rtems_bdbuf_remove_from_tree>: return bdbuf_cache.buffer_waiters.count; } static void rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd) {
4000e420:	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;                                     
4000e424:	35 10 00 71 	sethi  %hi(0x4001c400), %i2                    
4000e428:	b4 16 a1 8c 	or  %i2, 0x18c, %i2	! 4001c58c <bdbuf_cache>   
4000e42c:	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));                           
4000e430:	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;                             
4000e434:	f8 06 20 14 	ld  [ %i0 + 0x14 ], %i4                        
  rtems_blkdev_bnum block = node->block;                              
4000e438:	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));                           
4000e43c:	90 10 00 1b 	mov  %i3, %o0                                  
4000e440:	92 10 20 00 	clr  %o1                                       
4000e444:	40 00 1e 21 	call  40015cc8 <memset>                        
4000e448:	94 10 20 80 	mov  0x80, %o2                                 
                                                                      
  while (p != NULL)                                                   
4000e44c:	80 a7 60 00 	cmp  %i5, 0                                    
4000e450:	02 80 00 11 	be  4000e494 <rtems_bdbuf_remove_from_tree+0x74><== NEVER TAKEN
4000e454:	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;                                               
4000e458:	88 10 20 01 	mov  1, %g4                                    
      p = p->avl.right;                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
    {                                                                 
      p->avl.cache = -1;                                              
4000e45c:	b2 10 3f ff 	mov  -1, %i1                                   
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000e460:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
4000e464:	fa 20 80 00 	st  %i5, [ %g2 ]                               
                                                                      
    if (((uintptr_t) p->dd < (uintptr_t) dd)                          
4000e468:	80 a0 c0 1c 	cmp  %g3, %i4                                  
4000e46c:	0a 80 00 65 	bcs  4000e600 <rtems_bdbuf_remove_from_tree+0x1e0><== NEVER TAKEN
4000e470:	82 00 a0 04 	add  %g2, 4, %g1                               
        || ((p->dd == dd) && (p->block < block)))                     
4000e474:	80 a7 00 03 	cmp  %i4, %g3                                  
4000e478:	22 80 00 0a 	be,a   4000e4a0 <rtems_bdbuf_remove_from_tree+0x80><== ALWAYS TAKEN
4000e47c:	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;                                              
4000e480:	f2 2f 60 10 	stb  %i1, [ %i5 + 0x10 ]                       <== NOT EXECUTED
      p = p->avl.left;                                                
4000e484:	fa 07 60 08 	ld  [ %i5 + 8 ], %i5                           
                                                                      
  bool modified = false;                                              
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
4000e488:	80 a7 60 00 	cmp  %i5, 0                                    
4000e48c:	12 bf ff f5 	bne  4000e460 <rtems_bdbuf_remove_from_tree+0x40><== ALWAYS TAKEN
4000e490:	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);
4000e494:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        <== NOT EXECUTED
4000e498:	7f ff fe c9 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000e49c:	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)))                     
4000e4a0:	80 a4 00 03 	cmp  %l0, %g3                                  
4000e4a4:	38 80 00 58 	bgu,a   4000e604 <rtems_bdbuf_remove_from_tree+0x1e4>
4000e4a8:	c8 2f 60 10 	stb  %g4, [ %i5 + 0x10 ]                       
    {                                                                 
      p->avl.cache = 1;                                               
      p = p->avl.right;                                               
    }                                                                 
    else if ((p->dd != dd) || (p->block != block))                    
4000e4ac:	80 a4 00 03 	cmp  %l0, %g3                                  
4000e4b0:	32 bf ff f5 	bne,a   4000e484 <rtems_bdbuf_remove_from_tree+0x64>
4000e4b4:	f2 2f 60 10 	stb  %i1, [ %i5 + 0x10 ]                       
                                                                      
  memset (buf_stack, 0, sizeof(buf_stack));                           
                                                                      
  while (p != NULL)                                                   
  {                                                                   
    *buf_prev++ = p;                                                  
4000e4b8:	9a 10 00 01 	mov  %g1, %o5                                  
  }                                                                   
                                                                      
  q = p;                                                              
                                                                      
  buf_prev--;                                                         
  if (buf_prev > buf_stack)                                           
4000e4bc:	80 a0 80 1b 	cmp  %g2, %i3                                  
4000e4c0:	18 80 00 6a 	bgu  4000e668 <rtems_bdbuf_remove_from_tree+0x248>
4000e4c4:	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)                                           
4000e4c8:	f2 07 60 0c 	ld  [ %i5 + 0xc ], %i1                         
4000e4cc:	80 a6 60 00 	cmp  %i1, 0                                    
4000e4d0:	22 80 00 6b 	be,a   4000e67c <rtems_bdbuf_remove_from_tree+0x25c>
4000e4d4:	c6 07 60 08 	ld  [ %i5 + 8 ], %g3                           
  {                                                                   
    rtems_bdbuf_buffer **t;                                           
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
4000e4d8:	c6 06 60 08 	ld  [ %i1 + 8 ], %g3                           
4000e4dc:	84 10 00 19 	mov  %i1, %g2                                  
4000e4e0:	80 a0 e0 00 	cmp  %g3, 0                                    
4000e4e4:	12 80 00 06 	bne  4000e4fc <rtems_bdbuf_remove_from_tree+0xdc>
4000e4e8:	b8 10 3f ff 	mov  -1, %i4                                   
    {                                                                 
      r->avl.left = q->avl.left;                                      
4000e4ec:	10 80 00 ba 	b  4000e7d4 <rtems_bdbuf_remove_from_tree+0x3b4>
4000e4f0:	c6 07 60 08 	ld  [ %i5 + 8 ], %g3                           
    else                                                              
    {                                                                 
      t = buf_prev++;                                                 
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
4000e4f4:	84 10 00 03 	mov  %g3, %g2                                  
4000e4f8:	86 10 00 04 	mov  %g4, %g3                                  
4000e4fc:	c8 00 e0 08 	ld  [ %g3 + 8 ], %g4                           
      {                                                               
        *buf_prev++ = r = s;                                          
4000e500:	c4 20 40 00 	st  %g2, [ %g1 ]                               
        s = r->avl.left;                                              
        r->avl.cache = -1;                                            
4000e504:	f8 28 a0 10 	stb  %i4, [ %g2 + 0x10 ]                       
    else                                                              
    {                                                                 
      t = buf_prev++;                                                 
      s = r;                                                          
                                                                      
      while (s->avl.left != NULL)                                     
4000e508:	80 a1 20 00 	cmp  %g4, 0                                    
4000e50c:	12 bf ff fa 	bne  4000e4f4 <rtems_bdbuf_remove_from_tree+0xd4>
4000e510:	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;                                      
4000e514:	de 07 60 08 	ld  [ %i5 + 8 ], %o7                           
      r->avl.left = s->avl.right;                                     
4000e518:	f8 00 e0 0c 	ld  [ %g3 + 0xc ], %i4                         
      s->avl.right = q->avl.right;                                    
      s->avl.bal = q->avl.bal;                                        
4000e51c:	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;                                      
4000e520:	de 20 e0 08 	st  %o7, [ %g3 + 8 ]                           
      r->avl.left = s->avl.right;                                     
4000e524:	f8 20 a0 08 	st  %i4, [ %g2 + 8 ]                           
      s->avl.right = q->avl.right;                                    
4000e528:	f2 20 e0 0c 	st  %i1, [ %g3 + 0xc ]                         
      s->avl.bal = q->avl.bal;                                        
      s->avl.cache = 1;                                               
4000e52c:	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;                                        
4000e530:	c8 28 e0 11 	stb  %g4, [ %g3 + 0x11 ]                       
      s->avl.cache = 1;                                               
4000e534:	c4 28 e0 10 	stb  %g2, [ %g3 + 0x10 ]                       
                                                                      
      *t = q = s;                                                     
4000e538:	c6 23 7f fc 	st  %g3, [ %o5 + -4 ]                          
    }                                                                 
  }                                                                   
                                                                      
  if (p != NULL)                                                      
4000e53c:	80 a6 20 00 	cmp  %i0, 0                                    
4000e540:	22 80 00 07 	be,a   4000e55c <rtems_bdbuf_remove_from_tree+0x13c>
4000e544:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        
  {                                                                   
    if (p->avl.cache == -1)                                           
4000e548:	c4 4e 20 10 	ldsb  [ %i0 + 0x10 ], %g2                      
4000e54c:	80 a0 bf ff 	cmp  %g2, -1                                   
4000e550:	22 80 00 03 	be,a   4000e55c <rtems_bdbuf_remove_from_tree+0x13c>
4000e554:	c6 26 20 08 	st  %g3, [ %i0 + 8 ]                           
    {                                                                 
      p->avl.left = q;                                                
    }                                                                 
    else                                                              
    {                                                                 
      p->avl.right = q;                                               
4000e558:	c6 26 20 0c 	st  %g3, [ %i0 + 0xc ]                         
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
  {                                                                   
    if (buf_prev > buf_stack)                                         
4000e55c:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000e560:	08 80 00 26 	bleu  4000e5f8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000e564:	b2 10 3f ff 	mov  -1, %i1                                   
4000e568:	c4 00 7f fc 	ld  [ %g1 + -4 ], %g2                          
4000e56c:	c8 08 a0 10 	ldub  [ %g2 + 0x10 ], %g4                      
4000e570:	10 80 00 10 	b  4000e5b0 <rtems_bdbuf_remove_from_tree+0x190>
4000e574:	89 29 20 18 	sll  %g4, 0x18, %g4                            
        case +1:                                                      
          p->avl.bal = 0;                                             
          break;                                                      
                                                                      
        case  0:                                                      
          p->avl.bal = -1;                                            
4000e578:	86 10 00 02 	mov  %g2, %g3                                  
          modified = false;                                           
4000e57c:	ba 10 20 00 	clr  %i5                                       
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
                                                                      
    if (buf_prev > buf_stack)                                         
4000e580:	80 a0 40 1b 	cmp  %g1, %i3                                  
4000e584:	28 80 00 1d 	bleu,a   4000e5f8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000e588:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        
    {                                                                 
      q = *(buf_prev - 1);                                            
4000e58c:	c4 00 7f fc 	ld  [ %g1 + -4 ], %g2                          
                                                                      
      if (q->avl.cache == -1)                                         
4000e590:	c8 08 a0 10 	ldub  [ %g2 + 0x10 ], %g4                      
4000e594:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4000e598:	b9 39 20 18 	sra  %g4, 0x18, %i4                            
4000e59c:	80 a7 3f ff 	cmp  %i4, -1                                   
4000e5a0:	02 80 00 47 	be  4000e6bc <rtems_bdbuf_remove_from_tree+0x29c>
4000e5a4:	80 8f 60 ff 	btst  0xff, %i5                                
    *root = q;                                                        
  }                                                                   
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
4000e5a8:	02 80 00 14 	be  4000e5f8 <rtems_bdbuf_remove_from_tree+0x1d8>
4000e5ac:	c6 20 a0 0c 	st  %g3, [ %g2 + 0xc ]                         
    else                                                              
    {                                                                 
      break;                                                          
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
4000e5b0:	89 39 20 18 	sra  %g4, 0x18, %g4                            
                                                                      
  while (modified)                                                    
  {                                                                   
    if (buf_prev > buf_stack)                                         
    {                                                                 
      p = *--buf_prev;                                                
4000e5b4:	82 00 7f fc 	add  %g1, -4, %g1                              
    else                                                              
    {                                                                 
      break;                                                          
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
4000e5b8:	80 a1 3f ff 	cmp  %g4, -1                                   
4000e5bc:	02 80 00 38 	be  4000e69c <rtems_bdbuf_remove_from_tree+0x27c>
4000e5c0:	c6 48 a0 11 	ldsb  [ %g2 + 0x11 ], %g3                      
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
4000e5c4:	80 a0 e0 00 	cmp  %g3, 0                                    
4000e5c8:	22 bf ff ec 	be,a   4000e578 <rtems_bdbuf_remove_from_tree+0x158>
4000e5cc:	f2 28 a0 11 	stb  %i1, [ %g2 + 0x11 ]                       
4000e5d0:	80 a0 e0 01 	cmp  %g3, 1                                    
4000e5d4:	02 80 00 42 	be  4000e6dc <rtems_bdbuf_remove_from_tree+0x2bc>
4000e5d8:	80 a0 ff ff 	cmp  %g3, -1                                   
4000e5dc:	22 80 00 0c 	be,a   4000e60c <rtems_bdbuf_remove_from_tree+0x1ec><== ALWAYS TAKEN
4000e5e0:	c8 00 a0 08 	ld  [ %g2 + 8 ], %g4                           
4000e5e4:	86 10 00 02 	mov  %g2, %g3                                  <== NOT EXECUTED
        default:                                                      
          break;                                                      
      }                                                               
    }                                                                 
                                                                      
    if (buf_prev > buf_stack)                                         
4000e5e8:	80 a0 40 1b 	cmp  %g1, %i3                                  <== NOT EXECUTED
4000e5ec:	18 bf ff e8 	bgu  4000e58c <rtems_bdbuf_remove_from_tree+0x16c><== NOT EXECUTED
4000e5f0:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
        q->avl.right = p;                                             
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      *root = p;                                                      
4000e5f4:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        <== NOT EXECUTED
4000e5f8:	81 c7 e0 08 	ret                                            
4000e5fc:	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;                                               
4000e600:	c8 2f 60 10 	stb  %g4, [ %i5 + 0x10 ]                       <== NOT EXECUTED
      p = p->avl.right;                                               
4000e604:	10 bf ff a1 	b  4000e488 <rtems_bdbuf_remove_from_tree+0x68>
4000e608:	fa 07 60 0c 	ld  [ %i5 + 0xc ], %i5                         
          break;                                                      
                                                                      
        case -1:                                                      
          p1 = p->avl.left;                                           
                                                                      
          if (p1->avl.bal <= 0) /* simple LL-turn */                  
4000e60c:	c6 49 20 11 	ldsb  [ %g4 + 0x11 ], %g3                      
4000e610:	80 a0 e0 00 	cmp  %g3, 0                                    
4000e614:	24 80 00 41 	ble,a   4000e718 <rtems_bdbuf_remove_from_tree+0x2f8>
4000e618:	fa 01 20 0c 	ld  [ %g4 + 0xc ], %i5                         
            }                                                         
            p = p1;                                                   
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
4000e61c:	c6 01 20 0c 	ld  [ %g4 + 0xc ], %g3                         
                                                                      
            p1->avl.right = p2->avl.left;                             
4000e620:	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;
4000e624:	fa 48 e0 11 	ldsb  [ %g3 + 0x11 ], %i5                      
          }                                                           
          else /* double LR-turn */                                   
          {                                                           
            p2 = p1->avl.right;                                       
                                                                      
            p1->avl.right = p2->avl.left;                             
4000e628:	f8 21 20 0c 	st  %i4, [ %g4 + 0xc ]                         
            p2->avl.left = p1;                                        
            p->avl.left = p2->avl.right;                              
4000e62c:	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;                                        
4000e630:	c8 20 e0 08 	st  %g4, [ %g3 + 8 ]                           
            p->avl.left = p2->avl.right;                              
4000e634:	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;
4000e638:	80 a7 7f ff 	cmp  %i5, -1                                   
4000e63c:	02 80 00 40 	be  4000e73c <rtems_bdbuf_remove_from_tree+0x31c>
4000e640:	c4 20 e0 0c 	st  %g2, [ %g3 + 0xc ]                         
4000e644:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000e648:	c4 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g2                      
4000e64c:	80 a0 a0 01 	cmp  %g2, 1                                    
4000e650:	22 80 00 42 	be,a   4000e758 <rtems_bdbuf_remove_from_tree+0x338>
4000e654:	f2 29 20 11 	stb  %i1, [ %g4 + 0x11 ]                       
4000e658:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
4000e65c:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
4000e660:	10 bf ff c8 	b  4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e664:	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)                                           
4000e668:	f2 07 60 0c 	ld  [ %i5 + 0xc ], %i1                         
4000e66c:	80 a6 60 00 	cmp  %i1, 0                                    
4000e670:	12 bf ff 9a 	bne  4000e4d8 <rtems_bdbuf_remove_from_tree+0xb8>
4000e674:	f0 00 7f f8 	ld  [ %g1 + -8 ], %i0                          
  {                                                                   
    r = q->avl.left;                                                  
4000e678:	c6 07 60 08 	ld  [ %i5 + 8 ], %g3                           
    if (r != NULL)                                                    
4000e67c:	80 a0 e0 00 	cmp  %g3, 0                                    
4000e680:	02 80 00 61 	be  4000e804 <rtems_bdbuf_remove_from_tree+0x3e4>
4000e684:	80 a6 20 00 	cmp  %i0, 0                                    
    {                                                                 
      r->avl.bal = 0;                                                 
4000e688:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
                                                                      
      *t = q = s;                                                     
    }                                                                 
  }                                                                   
                                                                      
  if (p != NULL)                                                      
4000e68c:	12 bf ff af 	bne  4000e548 <rtems_bdbuf_remove_from_tree+0x128>
4000e690:	82 10 00 02 	mov  %g2, %g1                                  
      p->avl.right = q;                                               
    }                                                                 
  }                                                                   
  else                                                                
  {                                                                   
    *root = q;                                                        
4000e694:	10 bf ff b2 	b  4000e55c <rtems_bdbuf_remove_from_tree+0x13c>
4000e698:	c6 26 a0 3c 	st  %g3, [ %i2 + 0x3c ]                        
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
    {                                                                 
      /* rebalance left branch */                                     
      switch (p->avl.bal)                                             
4000e69c:	80 a0 e0 00 	cmp  %g3, 0                                    
4000e6a0:	12 80 00 0b 	bne  4000e6cc <rtems_bdbuf_remove_from_tree+0x2ac>
4000e6a4:	80 a0 e0 01 	cmp  %g3, 1                                    
      {                                                               
        case -1:                                                      
          p->avl.bal = 0;                                             
          break;                                                      
        case  0:                                                      
          p->avl.bal = 1;                                             
4000e6a8:	88 10 20 01 	mov  1, %g4                                    
4000e6ac:	86 10 00 02 	mov  %g2, %g3                                  
4000e6b0:	c8 28 a0 11 	stb  %g4, [ %g2 + 0x11 ]                       
          modified = false;                                           
4000e6b4:	10 bf ff b3 	b  4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e6b8:	ba 10 20 00 	clr  %i5                                       
    *root = q;                                                        
  }                                                                   
                                                                      
  modified = true;                                                    
                                                                      
  while (modified)                                                    
4000e6bc:	12 bf ff bd 	bne  4000e5b0 <rtems_bdbuf_remove_from_tree+0x190>
4000e6c0:	c6 20 a0 08 	st  %g3, [ %g2 + 8 ]                           
4000e6c4:	81 c7 e0 08 	ret                                            
4000e6c8:	81 e8 00 00 	restore                                        
    }                                                                 
                                                                      
    if (p->avl.cache == -1)                                           
    {                                                                 
      /* rebalance left branch */                                     
      switch (p->avl.bal)                                             
4000e6cc:	02 80 00 08 	be  4000e6ec <rtems_bdbuf_remove_from_tree+0x2cc>
4000e6d0:	80 a0 ff ff 	cmp  %g3, -1                                   
4000e6d4:	32 bf ff c5 	bne,a   4000e5e8 <rtems_bdbuf_remove_from_tree+0x1c8><== NEVER TAKEN
4000e6d8:	86 10 00 02 	mov  %g2, %g3                                  <== NOT EXECUTED
    {                                                                 
      /* rebalance right branch */                                    
      switch (p->avl.bal)                                             
      {                                                               
        case +1:                                                      
          p->avl.bal = 0;                                             
4000e6dc:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
4000e6e0:	86 10 00 02 	mov  %g2, %g3                                  
4000e6e4:	10 bf ff a7 	b  4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e6e8:	ba 10 20 01 	mov  1, %i5                                    
          p->avl.bal = 1;                                             
          modified = false;                                           
          break;                                                      
                                                                      
        case +1:                                                      
          p1 = p->avl.right;                                          
4000e6ec:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
                                                                      
          if (p1->avl.bal >= 0) /* simple RR-turn */                  
4000e6f0:	fa 48 e0 11 	ldsb  [ %g3 + 0x11 ], %i5                      
4000e6f4:	80 a7 60 00 	cmp  %i5, 0                                    
4000e6f8:	26 80 00 24 	bl,a   4000e788 <rtems_bdbuf_remove_from_tree+0x368>
4000e6fc:	fa 00 e0 08 	ld  [ %g3 + 8 ], %i5                           
          {                                                           
            p->avl.right = p1->avl.left;                              
4000e700:	f8 00 e0 08 	ld  [ %g3 + 8 ], %i4                           
            p1->avl.left = p;                                         
4000e704:	c4 20 e0 08 	st  %g2, [ %g3 + 8 ]                           
                                                                      
            if (p1->avl.bal == 0)                                     
4000e708:	12 80 00 17 	bne  4000e764 <rtems_bdbuf_remove_from_tree+0x344>
4000e70c:	f8 20 a0 0c 	st  %i4, [ %g2 + 0xc ]                         
            {                                                         
              p1->avl.bal = -1;                                       
4000e710:	10 bf ff 9c 	b  4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e714:	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;                                        
4000e718:	c4 21 20 0c 	st  %g2, [ %g4 + 0xc ]                         
            if (p1->avl.bal == 0)                                     
4000e71c:	80 a0 e0 00 	cmp  %g3, 0                                    
4000e720:	12 80 00 15 	bne  4000e774 <rtems_bdbuf_remove_from_tree+0x354>
4000e724:	fa 20 a0 08 	st  %i5, [ %g2 + 8 ]                           
            {                                                         
              p1->avl.bal = 1;                                        
4000e728:	84 10 20 01 	mov  1, %g2                                    
4000e72c:	86 10 00 04 	mov  %g4, %g3                                  
4000e730:	c4 29 20 11 	stb  %g2, [ %g4 + 0x11 ]                       
              modified = false;                                       
4000e734:	10 bf ff 93 	b  4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e738:	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;
4000e73c:	ba 10 20 01 	mov  1, %i5                                    
4000e740:	fa 28 a0 11 	stb  %i5, [ %g2 + 0x11 ]                       
            if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
4000e744:	c4 48 e0 11 	ldsb  [ %g3 + 0x11 ], %g2                      
4000e748:	80 a0 a0 01 	cmp  %g2, 1                                    
4000e74c:	32 bf ff c4 	bne,a   4000e65c <rtems_bdbuf_remove_from_tree+0x23c><== ALWAYS TAKEN
4000e750:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
4000e754:	f2 29 20 11 	stb  %i1, [ %g4 + 0x11 ]                       <== NOT EXECUTED
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
4000e758:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
4000e75c:	10 bf ff 89 	b  4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e760:	ba 10 20 01 	mov  1, %i5                                    
              p1->avl.bal = -1;                                       
              modified = false;                                       
            }                                                         
            else                                                      
            {                                                         
              p->avl.bal = 0;                                         
4000e764:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
              p1->avl.bal = 0;                                        
4000e768:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
4000e76c:	10 bf ff 85 	b  4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e770:	ba 10 20 01 	mov  1, %i5                                    
              p1->avl.bal = 1;                                        
              modified = false;                                       
            }                                                         
            else                                                      
            {                                                         
              p->avl.bal = 0;                                         
4000e774:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
              p1->avl.bal = 0;                                        
4000e778:	c0 29 20 11 	clrb  [ %g4 + 0x11 ]                           
4000e77c:	86 10 00 04 	mov  %g4, %g3                                  
4000e780:	10 bf ff 80 	b  4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e784:	ba 10 20 01 	mov  1, %i5                                    
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
4000e788:	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;
4000e78c:	f8 4f 60 11 	ldsb  [ %i5 + 0x11 ], %i4                      
          }                                                           
          else /* double RL-turn */                                   
          {                                                           
            p2 = p1->avl.left;                                        
                                                                      
            p1->avl.left = p2->avl.right;                             
4000e790:	f0 20 e0 08 	st  %i0, [ %g3 + 8 ]                           
            p2->avl.right = p1;                                       
            p->avl.right = p2->avl.left;                              
4000e794:	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;                                       
4000e798:	c6 27 60 0c 	st  %g3, [ %i5 + 0xc ]                         
            p->avl.right = p2->avl.left;                              
4000e79c:	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;
4000e7a0:	80 a7 20 01 	cmp  %i4, 1                                    
4000e7a4:	02 80 00 16 	be  4000e7fc <rtems_bdbuf_remove_from_tree+0x3dc>
4000e7a8:	c4 27 60 08 	st  %g2, [ %i5 + 8 ]                           
4000e7ac:	c0 28 a0 11 	clrb  [ %g2 + 0x11 ]                           
            if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
4000e7b0:	c4 4f 60 11 	ldsb  [ %i5 + 0x11 ], %g2                      
4000e7b4:	80 a0 bf ff 	cmp  %g2, -1                                   
4000e7b8:	02 80 00 0f 	be  4000e7f4 <rtems_bdbuf_remove_from_tree+0x3d4><== NEVER TAKEN
4000e7bc:	84 10 20 01 	mov  1, %g2                                    
4000e7c0:	c0 28 e0 11 	clrb  [ %g3 + 0x11 ]                           
                                                                      
            p = p2;                                                   
            p2->avl.bal = 0;                                          
4000e7c4:	c0 2f 60 11 	clrb  [ %i5 + 0x11 ]                           
4000e7c8:	86 10 00 1d 	mov  %i5, %g3                                  
4000e7cc:	10 bf ff 6d 	b  4000e580 <rtems_bdbuf_remove_from_tree+0x160>
4000e7d0:	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;                                        
4000e7d4:	c4 0f 60 11 	ldub  [ %i5 + 0x11 ], %g2                      
                                                                      
    r = q->avl.right;                                                 
                                                                      
    if (r->avl.left == NULL)                                          
    {                                                                 
      r->avl.left = q->avl.left;                                      
4000e7d8:	c6 26 60 08 	st  %g3, [ %i1 + 8 ]                           
      r->avl.bal = q->avl.bal;                                        
4000e7dc:	c4 2e 60 11 	stb  %g2, [ %i1 + 0x11 ]                       
      r->avl.cache = 1;                                               
      *buf_prev++ = q = r;                                            
4000e7e0:	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;                                               
4000e7e4:	84 10 20 01 	mov  1, %g2                                    
      *buf_prev++ = q = r;                                            
4000e7e8:	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;                                               
4000e7ec:	10 bf ff 54 	b  4000e53c <rtems_bdbuf_remove_from_tree+0x11c>
4000e7f0:	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;
4000e7f4:	10 bf ff f4 	b  4000e7c4 <rtems_bdbuf_remove_from_tree+0x3a4><== NOT EXECUTED
4000e7f8:	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;
4000e7fc:	10 bf ff ed 	b  4000e7b0 <rtems_bdbuf_remove_from_tree+0x390>
4000e800:	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)                                                    
4000e804:	10 bf ff 4e 	b  4000e53c <rtems_bdbuf_remove_from_tree+0x11c>
4000e808:	82 10 00 02 	mov  %g2, %g1                                  
                                                                      

4000e898 <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) {
4000e898:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch (bd->state)                                                  
4000e89c:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4000e8a0:	80 a2 20 00 	cmp  %o0, 0                                    
4000e8a4:	22 80 00 0a 	be,a   4000e8cc <rtems_bdbuf_remove_from_tree_and_lru_list+0x34>
4000e8a8:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000e8ac:	80 a2 20 02 	cmp  %o0, 2                                    
4000e8b0:	02 80 00 04 	be  4000e8c0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x28><== ALWAYS TAKEN
4000e8b4:	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);
4000e8b8:	7f ff fd c1 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4000e8bc:	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);                              
4000e8c0:	7f ff fe d8 	call  4000e420 <rtems_bdbuf_remove_from_tree>  
4000e8c4:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000e8c8:	c4 06 00 00 	ld  [ %i0 ], %g2                               
  previous       = the_node->previous;                                
4000e8cc:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
  next->previous = previous;                                          
4000e8d0:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
4000e8d4:	c4 20 40 00 	st  %g2, [ %g1 ]                               
4000e8d8:	81 c7 e0 08 	ret                                            
4000e8dc:	81 e8 00 00 	restore                                        
                                                                      

4000e080 <rtems_bdbuf_restore_preemption>: return prev_mode; } static void rtems_bdbuf_restore_preemption (rtems_mode prev_mode) {
4000e080:	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); 
4000e084:	13 00 00 3f 	sethi  %hi(0xfc00), %o1                        
  return prev_mode;                                                   
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)                 
{                                                                     
4000e088:	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); 
4000e08c:	90 10 00 18 	mov  %i0, %o0                                  
4000e090:	94 07 a0 44 	add  %fp, 0x44, %o2                            
4000e094:	40 00 12 3e 	call  4001298c <rtems_task_mode>               
4000e098:	92 12 63 ff 	or  %o1, 0x3ff, %o1                            
  if (sc != RTEMS_SUCCESSFUL)                                         
4000e09c:	80 a2 20 00 	cmp  %o0, 0                                    
4000e0a0:	12 80 00 04 	bne  4000e0b0 <rtems_bdbuf_restore_preemption+0x30><== NEVER TAKEN
4000e0a4:	01 00 00 00 	nop                                            
4000e0a8:	81 c7 e0 08 	ret                                            
4000e0ac:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_PREEMPT_RST);                
4000e0b0:	7f ff ff ab 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e0b4:	90 10 20 06 	mov  6, %o0                                    <== NOT EXECUTED
                                                                      

4001059c <rtems_bdbuf_set_block_size>: rtems_status_code rtems_bdbuf_set_block_size (rtems_disk_device *dd, uint32_t block_size, bool sync) {
4001059c:	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)                                                           
400105a0:	80 a6 a0 00 	cmp  %i2, 0                                    
400105a4:	12 80 00 43 	bne  400106b0 <rtems_bdbuf_set_block_size+0x114>
400105a8:	01 00 00 00 	nop                                            
    rtems_bdbuf_syncdev (dd);                                         
                                                                      
  rtems_bdbuf_lock_cache ();                                          
400105ac:	7f ff f6 7e 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
400105b0:	b8 10 20 0a 	mov  0xa, %i4	! a <PROM_START+0xa>             
                                                                      
  if (block_size > 0)                                                 
400105b4:	80 a6 60 00 	cmp  %i1, 0                                    
400105b8:	12 80 00 06 	bne  400105d0 <rtems_bdbuf_set_block_size+0x34>
400105bc:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
  else                                                                
  {                                                                   
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
400105c0:	7f ff f6 8f 	call  4000dffc <rtems_bdbuf_unlock_cache>      
400105c4:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  return sc;                                                          
}                                                                     
400105c8:	81 c7 e0 08 	ret                                            
400105cc:	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)                                 
400105d0:	82 10 63 d8 	or  %g1, 0x3d8, %g1                            
400105d4:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2                        
400105d8:	80 a6 40 02 	cmp  %i1, %g2                                  
400105dc:	18 bf ff f9 	bgu  400105c0 <rtems_bdbuf_set_block_size+0x24><== NEVER TAKEN
400105e0:	01 00 00 00 	nop                                            
    return 0;                                                         
                                                                      
  bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;         
400105e4:	d2 00 60 24 	ld  [ %g1 + 0x24 ], %o1                        
400105e8:	40 00 21 07 	call  40018a04 <.udiv>                         
400105ec:	90 06 7f ff 	add  %i1, -1, %o0                              
400105f0:	90 02 20 01 	inc  %o0                                       
                                                                      
  for (bds_per_size = 1;                                              
400105f4:	80 a2 20 01 	cmp  %o0, 1                                    
400105f8:	08 80 00 06 	bleu  40010610 <rtems_bdbuf_set_block_size+0x74>
400105fc:	92 10 20 01 	mov  1, %o1                                    
       bds_per_size < bufs_per_size;                                  
       bds_per_size <<= 1)                                            
40010600:	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;                                              
40010604:	80 a2 00 09 	cmp  %o0, %o1                                  
40010608:	38 bf ff ff 	bgu,a   40010604 <rtems_bdbuf_set_block_size+0x68>
4001060c:	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;                
40010610:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
40010614:	d0 00 61 ac 	ld  [ %g1 + 0x1ac ], %o0	! 4001c5ac <bdbuf_cache+0x20>
40010618:	40 00 20 fb 	call  40018a04 <.udiv>                         
4001061c:	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)                                           
40010620:	80 a2 20 00 	cmp  %o0, 0                                    
40010624:	02 bf ff e7 	be  400105c0 <rtems_bdbuf_set_block_size+0x24> <== NEVER TAKEN
40010628:	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;
4001062c:	f8 06 20 20 	ld  [ %i0 + 0x20 ], %i4                        
40010630:	90 10 00 19 	mov  %i1, %o0                                  
40010634:	92 10 00 1c 	mov  %i4, %o1                                  
40010638:	40 00 20 f3 	call  40018a04 <.udiv>                         
4001063c:	ba 10 20 00 	clr  %i5                                       
      uint32_t one = 1;                                               
                                                                      
      while ((one << block_to_media_block_shift) < media_blocks_per_block)
40010640:	80 a2 20 01 	cmp  %o0, 1                                    
40010644:	08 80 00 08 	bleu  40010664 <rtems_bdbuf_set_block_size+0xc8>
40010648:	b6 10 00 08 	mov  %o0, %i3                                  
4001064c:	84 10 20 01 	mov  1, %g2                                    
      {                                                               
        ++block_to_media_block_shift;                                 
40010650:	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)
40010654:	83 28 80 1d 	sll  %g2, %i5, %g1                             
40010658:	80 a6 c0 01 	cmp  %i3, %g1                                  
4001065c:	38 bf ff fe 	bgu,a   40010654 <rtems_bdbuf_set_block_size+0xb8>
40010660:	ba 07 60 01 	inc  %i5                                       
      {                                                               
        ++block_to_media_block_shift;                                 
      }                                                               
                                                                      
      if ((dd->media_block_size << block_to_media_block_shift) != block_size)
40010664:	b9 2f 00 1d 	sll  %i4, %i5, %i4                             
40010668:	80 a7 00 19 	cmp  %i4, %i1                                  
4001066c:	32 80 00 02 	bne,a   40010674 <rtems_bdbuf_set_block_size+0xd8><== NEVER TAKEN
40010670:	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;            
40010674:	d0 06 20 1c 	ld  [ %i0 + 0x1c ], %o0                        
40010678:	92 10 00 1b 	mov  %i3, %o1                                  
4001067c:	40 00 20 e2 	call  40018a04 <.udiv>                         
40010680:	f2 26 20 24 	st  %i1, [ %i0 + 0x24 ]                        
40010684:	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);                                     
40010688:	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;            
4001068c:	f6 26 20 2c 	st  %i3, [ %i0 + 0x2c ]                        
      dd->block_to_media_block_shift = block_to_media_block_shift;    
40010690:	fa 26 20 30 	st  %i5, [ %i0 + 0x30 ]                        
      dd->bds_per_group = bds_per_group;                              
40010694:	f4 26 20 34 	st  %i2, [ %i0 + 0x34 ]                        
                                                                      
      rtems_bdbuf_purge_dev (dd);                                     
40010698:	7f ff ff 43 	call  400103a4 <rtems_bdbuf_purge_dev>         
4001069c:	b8 10 20 00 	clr  %i4                                       
  else                                                                
  {                                                                   
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
400106a0:	7f ff f6 57 	call  4000dffc <rtems_bdbuf_unlock_cache>      
400106a4:	b0 10 00 1c 	mov  %i4, %i0                                  
                                                                      
  return sc;                                                          
}                                                                     
400106a8:	81 c7 e0 08 	ret                                            
400106ac:	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);                                         
400106b0:	7f ff ff 26 	call  40010348 <rtems_bdbuf_syncdev>           
400106b4:	90 10 00 18 	mov  %i0, %o0                                  
400106b8:	30 bf ff bd 	b,a   400105ac <rtems_bdbuf_set_block_size+0x10>
                                                                      

4000ddd8 <rtems_bdbuf_swapout_modified_processing>: rtems_chain_control* chain, rtems_chain_control* transfer, bool sync_active, bool update_timers, uint32_t timer_delta) {
4000ddd8:	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;                    
4000dddc:	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 );                            
4000dde0:	b2 06 60 04 	add  %i1, 4, %i1                               
  if (!rtems_chain_is_empty (chain))                                  
4000dde4:	80 a0 40 19 	cmp  %g1, %i1                                  
4000dde8:	02 80 00 2e 	be  4000dea0 <rtems_bdbuf_swapout_modified_processing+0xc8>
4000ddec:	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))                
4000ddf0:	12 80 00 57 	bne  4000df4c <rtems_bdbuf_swapout_modified_processing+0x174>
4000ddf4:	9e 10 20 00 	clr  %o7                                       
}                                                                     
                                                                      
static bool                                                           
rtems_bdbuf_has_buffer_waiters (void)                                 
{                                                                     
  return bdbuf_cache.buffer_waiters.count;                            
4000ddf8:	05 10 00 71 	sethi  %hi(0x4001c400), %g2                    
4000ddfc:	d8 00 a2 00 	ld  [ %g2 + 0x200 ], %o4	! 4001c600 <bdbuf_cache+0x74>
4000de00:	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;                                                  
4000de04:	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))            
4000de08:	80 a3 e0 00 	cmp  %o7, 0                                    
4000de0c:	32 80 00 3b 	bne,a   4000def8 <rtems_bdbuf_swapout_modified_processing+0x120>
4000de10:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000de14:	80 a6 e0 00 	cmp  %i3, 0                                    
4000de18:	02 80 00 07 	be  4000de34 <rtems_bdbuf_swapout_modified_processing+0x5c>
4000de1c:	80 a3 20 00 	cmp  %o4, 0                                    
4000de20:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000de24:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
4000de28:	80 a0 80 03 	cmp  %g2, %g3                                  
4000de2c:	02 80 00 34 	be  4000defc <rtems_bdbuf_swapout_modified_processing+0x124>
4000de30:	80 a3 20 00 	cmp  %o4, 0                                    
          || rtems_bdbuf_has_buffer_waiters ())                       
4000de34:	32 80 00 31 	bne,a   4000def8 <rtems_bdbuf_swapout_modified_processing+0x120>
4000de38:	c4 06 00 00 	ld  [ %i0 ], %g2                               
        bd->hold_timer = 0;                                           
                                                                      
      if (bd->hold_timer)                                             
4000de3c:	c4 00 60 2c 	ld  [ %g1 + 0x2c ], %g2                        
4000de40:	80 a0 a0 00 	cmp  %g2, 0                                    
4000de44:	02 80 00 0b 	be  4000de70 <rtems_bdbuf_swapout_modified_processing+0x98><== NEVER TAKEN
4000de48:	80 a7 20 00 	cmp  %i4, 0                                    
      {                                                               
        if (update_timers)                                            
4000de4c:	22 80 00 12 	be,a   4000de94 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000de50:	c2 00 40 00 	ld  [ %g1 ], %g1                               
        {                                                             
          if (bd->hold_timer > timer_delta)                           
4000de54:	80 a0 80 1d 	cmp  %g2, %i5                                  
4000de58:	28 80 00 3a 	bleu,a   4000df40 <rtems_bdbuf_swapout_modified_processing+0x168>
4000de5c:	c0 20 60 2c 	clr  [ %g1 + 0x2c ]                            
            bd->hold_timer -= timer_delta;                            
4000de60:	84 20 80 1d 	sub  %g2, %i5, %g2                             
          else                                                        
            bd->hold_timer = 0;                                       
        }                                                             
                                                                      
        if (bd->hold_timer)                                           
4000de64:	80 a0 a0 00 	cmp  %g2, 0                                    
4000de68:	12 80 00 0a 	bne  4000de90 <rtems_bdbuf_swapout_modified_processing+0xb8><== ALWAYS TAKEN
4000de6c:	c4 20 60 2c 	st  %g2, [ %g1 + 0x2c ]                        
4000de70:	c4 06 00 00 	ld  [ %i0 ], %g2                               <== NOT EXECUTED
4000de74:	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)                               
4000de78:	80 a0 a0 00 	cmp  %g2, 0                                    
4000de7c:	22 80 00 24 	be,a   4000df0c <rtems_bdbuf_swapout_modified_processing+0x134>
4000de80:	84 10 00 03 	mov  %g3, %g2                                  
        *dd_ptr = bd->dd;                                             
                                                                      
      if (bd->dd == *dd_ptr)                                          
4000de84:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000de88:	22 80 00 08 	be,a   4000dea8 <rtems_bdbuf_swapout_modified_processing+0xd0><== ALWAYS TAKEN
4000de8c:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
                                                                      
        node = next_node;                                             
      }                                                               
      else                                                            
      {                                                               
        node = node->next;                                            
4000de90:	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))                        
4000de94:	80 a0 40 19 	cmp  %g1, %i1                                  
4000de98:	12 bf ff dd 	bne  4000de0c <rtems_bdbuf_swapout_modified_processing+0x34>
4000de9c:	80 a3 e0 00 	cmp  %o7, 0                                    
4000dea0:	81 c7 e0 08 	ret                                            
4000dea4:	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;                     
4000dea8:	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;                                                  
4000deac:	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;                                          
4000deb0:	c4 23 60 04 	st  %g2, [ %o5 + 4 ]                           
  previous->next = next;                                              
4000deb4:	da 20 80 00 	st  %o5, [ %g2 ]                               
                                                                      
        rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);       
                                                                      
        rtems_chain_extract_unprotected (node);                       
                                                                      
        tnode = tnode->previous;                                      
4000deb8:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
                                                                      
        while (node && !rtems_chain_is_head (transfer, tnode))        
4000debc:	80 a0 80 1a 	cmp  %g2, %i2                                  
4000dec0:	22 80 00 1a 	be,a   4000df28 <rtems_bdbuf_swapout_modified_processing+0x150>
4000dec4:	c4 06 80 00 	ld  [ %i2 ], %g2                               
        {                                                             
          rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;      
                                                                      
          if (bd->block > tbd->block)                                 
4000dec8:	c6 00 a0 18 	ld  [ %g2 + 0x18 ], %g3                        
4000decc:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4000ded0:	80 a1 00 03 	cmp  %g4, %g3                                  
4000ded4:	28 80 00 11 	bleu,a   4000df18 <rtems_bdbuf_swapout_modified_processing+0x140>
4000ded8:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000dedc:	c6 00 80 00 	ld  [ %g2 ], %g3                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000dee0:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000dee4:	c2 20 80 00 	st  %g1, [ %g2 ]                               
  the_node->next        = before_node;                                
4000dee8:	c6 20 40 00 	st  %g3, [ %g1 ]                               
  before_node->previous = the_node;                                   
4000deec:	c2 20 e0 04 	st  %g1, [ %g3 + 4 ]                           
4000def0:	10 bf ff e9 	b  4000de94 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000def4:	82 10 00 0d 	mov  %o5, %g1                                  
4000def8:	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)                               
4000defc:	80 a0 a0 00 	cmp  %g2, 0                                    
4000df00:	12 bf ff e1 	bne  4000de84 <rtems_bdbuf_swapout_modified_processing+0xac>
4000df04:	c0 20 60 2c 	clr  [ %g1 + 0x2c ]                            
        *dd_ptr = bd->dd;                                             
4000df08:	84 10 00 03 	mov  %g3, %g2                                  
4000df0c:	c6 26 00 00 	st  %g3, [ %i0 ]                               
4000df10:	10 bf ff dd 	b  4000de84 <rtems_bdbuf_swapout_modified_processing+0xac>
4000df14:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
                                                                      
        rtems_chain_extract_unprotected (node);                       
                                                                      
        tnode = tnode->previous;                                      
                                                                      
        while (node && !rtems_chain_is_head (transfer, tnode))        
4000df18:	80 a0 80 1a 	cmp  %g2, %i2                                  
4000df1c:	32 bf ff ec 	bne,a   4000decc <rtems_bdbuf_swapout_modified_processing+0xf4>
4000df20:	c6 00 a0 18 	ld  [ %g2 + 0x18 ], %g3                        
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
4000df24:	c4 06 80 00 	ld  [ %i2 ], %g2                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000df28:	f4 20 60 04 	st  %i2, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000df2c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
  the_node->next        = before_node;                                
4000df30:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  before_node->previous = the_node;                                   
4000df34:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
4000df38:	10 bf ff d7 	b  4000de94 <rtems_bdbuf_swapout_modified_processing+0xbc>
4000df3c:	82 10 00 0d 	mov  %o5, %g1                                  
4000df40:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000df44:	10 bf ff cd 	b  4000de78 <rtems_bdbuf_swapout_modified_processing+0xa0>
4000df48:	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))                
4000df4c:	c4 06 00 00 	ld  [ %i0 ], %g2                               
4000df50:	80 a0 00 02 	cmp  %g0, %g2                                  
4000df54:	10 bf ff a9 	b  4000ddf8 <rtems_bdbuf_swapout_modified_processing+0x20>
4000df58:	9e 60 3f ff 	subx  %g0, -1, %o7                             
                                                                      

4000f2f4 <rtems_bdbuf_swapout_task>: * not this. * @return rtems_task Not used. */ static rtems_task rtems_bdbuf_swapout_task (rtems_task_argument arg) {
4000f2f4:	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;
4000f2f8:	23 10 00 6a 	sethi  %hi(0x4001a800), %l1                    
4000f2fc:	a2 14 63 d8 	or  %l1, 0x3d8, %l1	! 4001abd8 <rtems_bdbuf_configuration>
  uint32_t                     timer_delta;                           
                                                                      
  transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();         
4000f300:	7f ff fb b2 	call  4000e1c8 <rtems_bdbuf_swapout_writereq_alloc>
4000f304:	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);
4000f308:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
4000f30c:	d2 00 63 9c 	ld  [ %g1 + 0x39c ], %o1	! 4001ab9c <Configuration+0xc>
4000f310:	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 ();         
4000f314:	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;                                                  
4000f318:	b4 07 bf e8 	add  %fp, -24, %i2                             
4000f31c:	b0 07 bf ec 	add  %fp, -20, %i0                             
  head->previous = NULL;                                              
4000f320:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000f324:	f0 27 bf e8 	st  %i0, [ %fp + -24 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000f328:	f4 27 bf f0 	st  %i2, [ %fp + -16 ]                         
  rtems_chain_initialize_empty (&transfer.bds);                       
  transfer.dd = BDBUF_INVALID_DEV;                                    
4000f32c:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  transfer.syncing = false;                                           
4000f330:	c0 2f bf f8 	clrb  [ %fp + -8 ]                             
                                                                      
  /*                                                                  
   * Localise the period.                                             
   */                                                                 
  period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
4000f334:	91 2e e0 07 	sll  %i3, 7, %o0                               
4000f338:	90 22 00 01 	sub  %o0, %g1, %o0                             
4000f33c:	90 02 00 1b 	add  %o0, %i3, %o0                             
4000f340:	40 00 25 b1 	call  40018a04 <.udiv>                         
4000f344:	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 ();                                          
4000f348:	7f ff fb 17 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
4000f34c:	ac 10 00 08 	mov  %o0, %l6                                  
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
4000f350:	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)                    
4000f354:	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++)                  
4000f358:	80 a0 60 00 	cmp  %g1, 0                                    
4000f35c:	02 80 00 c3 	be  4000f668 <rtems_bdbuf_swapout_task+0x374>  <== ALWAYS TAKEN
4000f360:	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;                              
4000f364:	21 10 00 71 	sethi  %hi(0x4001c400), %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),
4000f368:	29 10 91 1b 	sethi  %hi(0x42446c00), %l4                    <== NOT EXECUTED
4000f36c:	a0 14 21 8c 	or  %l0, 0x18c, %l0                            <== NOT EXECUTED
4000f370:	27 10 00 3d 	sethi  %hi(0x4000f400), %l3                    <== NOT EXECUTED
                                                                      
  the_node->next = tail;                                              
4000f374:	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;                                           
4000f378:	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),
4000f37c:	a8 15 23 00 	or  %l4, 0x300, %l4                            <== NOT EXECUTED
4000f380:	a6 14 e2 88 	or  %l3, 0x288, %l3                            <== NOT EXECUTED
                                                                      
  for (w = 0; w < bdbuf_config.swapout_workers; w++)                  
  {                                                                   
    rtems_bdbuf_swapout_worker* worker;                               
                                                                      
    worker = malloc (sizeof (rtems_bdbuf_swapout_worker));            
4000f384:	7f ff d9 3a 	call  4000586c <malloc>                        <== NOT EXECUTED
4000f388:	90 10 20 28 	mov  0x28, %o0                                 <== NOT EXECUTED
    if (!worker)                                                      
4000f38c:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4000f390:	02 80 00 bb 	be  4000f67c <rtems_bdbuf_swapout_task+0x388>  <== NOT EXECUTED
4000f394:	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;                              
4000f398:	c2 04 20 10 	ld  [ %l0 + 0x10 ], %g1                        <== NOT EXECUTED
                                                                      
  the_node->next = tail;                                              
4000f39c:	ee 27 40 00 	st  %l7, [ %i5 ]                               <== NOT EXECUTED
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
4000f3a0:	fa 20 40 00 	st  %i5, [ %g1 ]                               <== NOT EXECUTED
  the_node->previous = old_last;                                      
4000f3a4:	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;                                          
4000f3a8:	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 ();
4000f3ac:	7f ff fb 87 	call  4000e1c8 <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
4000f3b0:	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),
4000f3b4:	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 );                        
4000f3b8:	82 07 60 10 	add  %i5, 0x10, %g1                            <== NOT EXECUTED
4000f3bc:	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 ();
4000f3c0:	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),
4000f3c4:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
4000f3c8:	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;                                                  
4000f3cc:	c4 27 60 10 	st  %g2, [ %i5 + 0x10 ]                        <== NOT EXECUTED
  head->previous = NULL;                                              
  tail->previous = head;                                              
4000f3d0:	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;                          
4000f3d4:	c0 27 60 1c 	clr  [ %i5 + 0x1c ]                            <== NOT EXECUTED
                                                                      
    sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
4000f3d8:	90 16 40 14 	or  %i1, %l4, %o0                              <== NOT EXECUTED
4000f3dc:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
4000f3e0:	98 07 60 08 	add  %i5, 8, %o4                               <== NOT EXECUTED
4000f3e4:	7f ff fb f7 	call  4000e3c0 <rtems_bdbuf_create_task.constprop.9><== NOT EXECUTED
4000f3e8:	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)                                       
4000f3ec:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000f3f0:	12 80 00 a1 	bne  4000f674 <rtems_bdbuf_swapout_task+0x380> <== NOT EXECUTED
4000f3f4:	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++)                  
4000f3f8:	80 a6 40 12 	cmp  %i1, %l2                                  <== NOT EXECUTED
4000f3fc:	12 bf ff e2 	bne  4000f384 <rtems_bdbuf_swapout_task+0x90>  <== NOT EXECUTED
4000f400:	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 ();                                        
4000f404:	7f ff fa fe 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000f408:	01 00 00 00 	nop                                            
  /*                                                                  
   * Create the worker threads.                                       
   */                                                                 
  rtems_bdbuf_swapout_workers_open ();                                
                                                                      
  while (bdbuf_cache.swapout_enabled)                                 
4000f40c:	c2 0f 20 04 	ldub  [ %i4 + 4 ], %g1                         
4000f410:	80 a0 60 00 	cmp  %g1, 0                                    
4000f414:	02 80 00 75 	be  4000f5e8 <rtems_bdbuf_swapout_task+0x2f4>  <== NEVER TAKEN
4000f418:	82 07 20 08 	add  %i4, 8, %g1                               
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
4000f41c:	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,             
4000f420:	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))                                   
4000f424:	a8 07 20 0c 	add  %i4, 0xc, %l4                             
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
4000f428:	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;                                         
4000f42c:	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)                    
4000f430:	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;                        
4000f434:	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 ();                                          
4000f438:	7f ff fa db 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
4000f43c:	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)                                        
4000f440:	c2 0f 20 30 	ldub  [ %i4 + 0x30 ], %g1                      
4000f444:	80 a0 60 00 	cmp  %g1, 0                                    
4000f448:	32 80 00 2f 	bne,a   4000f504 <rtems_bdbuf_swapout_task+0x210>
4000f44c:	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;                    
4000f450:	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))                                   
4000f454:	80 a4 c0 14 	cmp  %l3, %l4                                  
4000f458:	02 80 00 7b 	be  4000f644 <rtems_bdbuf_swapout_task+0x350>  <== ALWAYS TAKEN
4000f45c:	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;                            
4000f460:	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;                                   
4000f464:	ba 04 e0 10 	add  %l3, 0x10, %i5                            <== NOT EXECUTED
                                                                      
  head->next = new_first;                                             
4000f468:	c4 27 20 08 	st  %g2, [ %i4 + 8 ]                           <== NOT EXECUTED
  new_first->previous = head;                                         
4000f46c:	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 );                        
4000f470:	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,             
4000f474:	a4 07 60 0c 	add  %i5, 0xc, %l2                             
4000f478:	96 10 20 01 	mov  1, %o3                                    
4000f47c:	98 10 20 00 	clr  %o4                                       
4000f480:	9a 10 00 1b 	mov  %i3, %o5                                  
4000f484:	90 10 00 12 	mov  %l2, %o0                                  
4000f488:	94 10 00 1d 	mov  %i5, %o2                                  
                                                                      
  head->next = tail;                                                  
4000f48c:	ee 27 40 00 	st  %l7, [ %i5 ]                               
  head->previous = NULL;                                              
4000f490:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
  tail->previous = head;                                              
4000f494:	fa 27 60 08 	st  %i5, [ %i5 + 8 ]                           
    if (worker)                                                       
      transfer = &worker->transfer;                                   
  }                                                                   
                                                                      
  rtems_chain_initialize_empty (&transfer->bds);                      
  transfer->dd = BDBUF_INVALID_DEV;                                   
4000f498:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
  transfer->syncing = bdbuf_cache.sync_active;                        
4000f49c:	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,             
4000f4a0:	13 10 00 71 	sethi  %hi(0x4001c400), %o1                    
4000f4a4:	7f ff fa 4d 	call  4000ddd8 <rtems_bdbuf_swapout_modified_processing>
4000f4a8:	92 12 61 e4 	or  %o1, 0x1e4, %o1	! 4001c5e4 <bdbuf_cache+0x58>
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
4000f4ac:	d2 07 bf dc 	ld  [ %fp + -36 ], %o1                         
4000f4b0:	d6 0f 20 30 	ldub  [ %i4 + 0x30 ], %o3                      
4000f4b4:	90 10 00 12 	mov  %l2, %o0                                  
4000f4b8:	94 10 00 1d 	mov  %i5, %o2                                  
4000f4bc:	98 0e 60 01 	and  %i1, 1, %o4                               
4000f4c0:	7f ff fa 46 	call  4000ddd8 <rtems_bdbuf_swapout_modified_processing>
4000f4c4:	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 ();                                        
4000f4c8:	7f ff fa cd 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000f4cc:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * If there are buffers to transfer to the media transfer them.     
   */                                                                 
  if (!rtems_chain_is_empty (&transfer->bds))                         
4000f4d0:	c6 07 40 00 	ld  [ %i5 ], %g3                               
4000f4d4:	80 a0 c0 17 	cmp  %g3, %l7                                  
4000f4d8:	02 80 00 28 	be  4000f578 <rtems_bdbuf_swapout_task+0x284>  
4000f4dc:	80 a4 e0 00 	cmp  %l3, 0                                    
  {                                                                   
    if (worker)                                                       
4000f4e0:	02 80 00 22 	be  4000f568 <rtems_bdbuf_swapout_task+0x274>  <== ALWAYS TAKEN
4000f4e4:	01 00 00 00 	nop                                            
    {                                                                 
      rtems_status_code sc = rtems_event_send (worker->id,            
4000f4e8:	d0 04 e0 08 	ld  [ %l3 + 8 ], %o0                           <== NOT EXECUTED
4000f4ec:	7f ff e8 04 	call  400094fc <rtems_event_send>              <== NOT EXECUTED
4000f4f0:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
                                               RTEMS_BDBUF_SWAPOUT_SYNC);
      if (sc != RTEMS_SUCCESSFUL)                                     
4000f4f4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4000f4f8:	12 80 00 56 	bne  4000f650 <rtems_bdbuf_swapout_task+0x35c> <== NOT EXECUTED
4000f4fc:	b2 10 20 00 	clr  %i1                                       <== NOT EXECUTED
4000f500:	30 bf ff ce 	b,a   4000f438 <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,             
4000f504:	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;                           
4000f508:	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,             
4000f50c:	98 10 20 00 	clr  %o4                                       
4000f510:	9a 10 00 1b 	mov  %i3, %o5                                  
4000f514:	90 07 bf f4 	add  %fp, -12, %o0                             
4000f518:	92 10 00 15 	mov  %l5, %o1                                  
4000f51c:	94 10 00 1a 	mov  %i2, %o2                                  
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
4000f520:	f0 27 bf e8 	st  %i0, [ %fp + -24 ]                         
  head->previous = NULL;                                              
4000f524:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  tail->previous = head;                                              
4000f528:	f4 27 bf f0 	st  %i2, [ %fp + -16 ]                         
4000f52c:	7f ff fa 2b 	call  4000ddd8 <rtems_bdbuf_swapout_modified_processing>
4000f530:	e0 2f bf f8 	stb  %l0, [ %fp + -8 ]                         
                                           timer_delta);              
                                                                      
  /*                                                                  
   * Process the cache's modified list.                               
   */                                                                 
  rtems_bdbuf_swapout_modified_processing (&transfer->dd,             
4000f534:	d6 0f 20 30 	ldub  [ %i4 + 0x30 ], %o3                      
4000f538:	90 07 bf f4 	add  %fp, -12, %o0                             
4000f53c:	92 10 00 11 	mov  %l1, %o1                                  
4000f540:	94 10 00 1a 	mov  %i2, %o2                                  
4000f544:	98 0e 60 01 	and  %i1, 1, %o4                               
4000f548:	7f ff fa 24 	call  4000ddd8 <rtems_bdbuf_swapout_modified_processing>
4000f54c:	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 ();                                        
4000f550:	7f ff fa ab 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000f554:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   * If there are buffers to transfer to the media transfer them.     
   */                                                                 
  if (!rtems_chain_is_empty (&transfer->bds))                         
4000f558:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
4000f55c:	80 a0 40 18 	cmp  %g1, %i0                                  
4000f560:	02 80 00 06 	be  4000f578 <rtems_bdbuf_swapout_task+0x284>  
4000f564:	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);                           
4000f568:	7f ff ff 09 	call  4000f18c <rtems_bdbuf_swapout_write>     
4000f56c:	90 10 00 1d 	mov  %i5, %o0                                  
4000f570:	10 bf ff b2 	b  4000f438 <rtems_bdbuf_swapout_task+0x144>   
4000f574:	b2 10 20 00 	clr  %i1                                       
    }                                                                 
                                                                      
    transfered_buffers = true;                                        
  }                                                                   
                                                                      
  if (bdbuf_cache.sync_active && !transfered_buffers)                 
4000f578:	c2 0f 20 30 	ldub  [ %i4 + 0x30 ], %g1                      
4000f57c:	80 a0 60 00 	cmp  %g1, 0                                    
4000f580:	02 80 00 0f 	be  4000f5bc <rtems_bdbuf_swapout_task+0x2c8>  
4000f584:	90 10 20 04 	mov  4, %o0                                    
  {                                                                   
    rtems_id sync_requester;                                          
    rtems_bdbuf_lock_cache ();                                        
4000f588:	7f ff fa 87 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
4000f58c:	01 00 00 00 	nop                                            
    sync_requester = bdbuf_cache.sync_requester;                      
4000f590:	fa 07 20 34 	ld  [ %i4 + 0x34 ], %i5                        
    bdbuf_cache.sync_active = false;                                  
4000f594:	c0 2f 20 30 	clrb  [ %i4 + 0x30 ]                           
    bdbuf_cache.sync_requester = 0;                                   
    rtems_bdbuf_unlock_cache ();                                      
4000f598:	7f ff fa 99 	call  4000dffc <rtems_bdbuf_unlock_cache>      
4000f59c:	c0 27 20 34 	clr  [ %i4 + 0x34 ]                            
    if (sync_requester)                                               
4000f5a0:	80 a7 60 00 	cmp  %i5, 0                                    
4000f5a4:	02 80 00 06 	be  4000f5bc <rtems_bdbuf_swapout_task+0x2c8>  <== NEVER TAKEN
4000f5a8:	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 ); 
4000f5ac:	90 10 00 1d 	mov  %i5, %o0                                  
4000f5b0:	7f ff e9 86 	call  40009bc8 <rtems_event_system_send>       
4000f5b4:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
       */                                                             
      update_timers = false;                                          
    }                                                                 
    while (transfered_buffers);                                       
                                                                      
    sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,               
4000f5b8:	90 10 20 04 	mov  4, %o0                                    
4000f5bc:	92 10 20 00 	clr  %o1                                       
4000f5c0:	94 10 00 16 	mov  %l6, %o2                                  
4000f5c4:	7f ff e7 6a 	call  4000936c <rtems_event_receive>           
4000f5c8:	96 07 bf e4 	add  %fp, -28, %o3                             
                              RTEMS_EVENT_ALL | RTEMS_WAIT,           
                              period_in_ticks,                        
                              &out);                                  
                                                                      
    if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))            
4000f5cc:	80 a2 20 06 	cmp  %o0, 6                                    
4000f5d0:	12 80 00 22 	bne  4000f658 <rtems_bdbuf_swapout_task+0x364> 
4000f5d4:	80 a2 20 00 	cmp  %o0, 0                                    
  /*                                                                  
   * Create the worker threads.                                       
   */                                                                 
  rtems_bdbuf_swapout_workers_open ();                                
                                                                      
  while (bdbuf_cache.swapout_enabled)                                 
4000f5d8:	c2 0f 20 04 	ldub  [ %i4 + 4 ], %g1                         
4000f5dc:	80 a0 60 00 	cmp  %g1, 0                                    
4000f5e0:	12 bf ff 95 	bne  4000f434 <rtems_bdbuf_swapout_task+0x140> <== ALWAYS TAKEN
4000f5e4:	b2 10 20 01 	mov  1, %i1                                    
static void                                                           
rtems_bdbuf_swapout_workers_close (void)                              
{                                                                     
  rtems_chain_node* node;                                             
                                                                      
  rtems_bdbuf_lock_cache ();                                          
4000f5e8:	7f ff fa 6f 	call  4000dfa4 <rtems_bdbuf_lock_cache>        <== NOT EXECUTED
4000f5ec:	01 00 00 00 	nop                                            <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000f5f0:	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))   
4000f5f4:	b8 07 20 0c 	add  %i4, 0xc, %i4                             <== NOT EXECUTED
4000f5f8:	80 a7 40 1c 	cmp  %i5, %i4                                  <== NOT EXECUTED
4000f5fc:	02 80 00 0a 	be  4000f624 <rtems_bdbuf_swapout_task+0x330>  <== NOT EXECUTED
4000f600:	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);          
4000f604:	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;                                          
4000f608:	c0 2f 60 0c 	clrb  [ %i5 + 0xc ]                            <== NOT EXECUTED
    rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);          
4000f60c:	7f ff e7 bc 	call  400094fc <rtems_event_send>              <== NOT EXECUTED
4000f610:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
4000f614:	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))   
4000f618:	80 a7 40 1c 	cmp  %i5, %i4                                  <== NOT EXECUTED
4000f61c:	32 bf ff fb 	bne,a   4000f608 <rtems_bdbuf_swapout_task+0x314><== NOT EXECUTED
4000f620:	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 ();                                        
4000f624:	7f ff fa 76 	call  4000dffc <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000f628:	01 00 00 00 	nop                                            <== NOT EXECUTED
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);               
  }                                                                   
                                                                      
  rtems_bdbuf_swapout_workers_close ();                               
                                                                      
  free (transfer.write_req);                                          
4000f62c:	7f ff d7 48 	call  4000534c <free>                          <== NOT EXECUTED
4000f630:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          <== NOT EXECUTED
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
4000f634:	7f ff e9 c3 	call  40009d40 <rtems_task_delete>             <== NOT EXECUTED
4000f638:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4000f63c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000f640:	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))                                   
4000f644:	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,                
4000f648:	10 bf ff 8a 	b  4000f470 <rtems_bdbuf_swapout_task+0x17c>   
4000f64c:	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);              
4000f650:	7f ff fa 43 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000f654:	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))            
4000f658:	22 bf ff e1 	be,a   4000f5dc <rtems_bdbuf_swapout_task+0x2e8><== ALWAYS TAKEN
4000f65c:	c2 0f 20 04 	ldub  [ %i4 + 4 ], %g1                         
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SWAPOUT_RE);               
4000f660:	7f ff fa 3f 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000f664:	90 10 20 18 	mov  0x18, %o0                                 <== NOT EXECUTED
4000f668:	39 10 00 71 	sethi  %hi(0x4001c400), %i4                    
4000f66c:	10 bf ff 66 	b  4000f404 <rtems_bdbuf_swapout_task+0x110>   
4000f670:	b8 17 21 8c 	or  %i4, 0x18c, %i4	! 4001c58c <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);             
4000f674:	7f ff fa 3a 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000f678:	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);              
4000f67c:	7f ff fa 38 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000f680:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
                                                                      

4000f688 <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) {
4000f688:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
                                                                      
  while (worker->enabled)                                             
4000f68c:	c2 0e 20 0c 	ldub  [ %i0 + 0xc ], %g1                       <== NOT EXECUTED
4000f690:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000f694:	02 80 00 1b 	be  4000f700 <rtems_bdbuf_swapout_worker_task+0x78><== NOT EXECUTED
4000f698:	ba 10 00 18 	mov  %i0, %i5                                  <== NOT EXECUTED
4000f69c:	39 10 00 71 	sethi  %hi(0x4001c400), %i4                    <== NOT EXECUTED
4000f6a0:	b6 06 20 10 	add  %i0, 0x10, %i3                            <== NOT EXECUTED
4000f6a4:	b8 17 21 8c 	or  %i4, 0x18c, %i4                            <== NOT EXECUTED
4000f6a8:	b2 06 20 14 	add  %i0, 0x14, %i1                            <== NOT EXECUTED
4000f6ac:	b4 07 20 0c 	add  %i4, 0xc, %i2                             <== NOT EXECUTED
  {                                                                   
    rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);            
4000f6b0:	7f ff fa b4 	call  4000e180 <rtems_bdbuf_wait_for_event>    <== NOT EXECUTED
4000f6b4:	90 10 20 04 	mov  4, %o0                                    <== NOT EXECUTED
                                                                      
    rtems_bdbuf_swapout_write (&worker->transfer);                    
4000f6b8:	7f ff fe b5 	call  4000f18c <rtems_bdbuf_swapout_write>     <== NOT EXECUTED
4000f6bc:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
                                                                      
    rtems_bdbuf_lock_cache ();                                        
4000f6c0:	7f ff fa 39 	call  4000dfa4 <rtems_bdbuf_lock_cache>        <== NOT EXECUTED
4000f6c4:	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;                              
4000f6c8:	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;                                                  
4000f6cc:	f2 27 60 10 	st  %i1, [ %i5 + 0x10 ]                        <== NOT EXECUTED
                                                                      
    rtems_chain_initialize_empty (&worker->transfer.bds);             
    worker->transfer.dd = BDBUF_INVALID_DEV;                          
4000f6d0:	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;                                              
4000f6d4:	f4 27 40 00 	st  %i2, [ %i5 ]                               <== NOT EXECUTED
  tail->previous = the_node;                                          
4000f6d8:	fa 27 20 10 	st  %i5, [ %i4 + 0x10 ]                        <== NOT EXECUTED
  old_last->next = the_node;                                          
4000f6dc:	fa 20 40 00 	st  %i5, [ %g1 ]                               <== NOT EXECUTED
  the_node->previous = old_last;                                      
4000f6e0:	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;                                              
4000f6e4:	c0 27 60 14 	clr  [ %i5 + 0x14 ]                            <== NOT EXECUTED
                                                                      
    rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
                                                                      
    rtems_bdbuf_unlock_cache ();                                      
4000f6e8:	7f ff fa 45 	call  4000dffc <rtems_bdbuf_unlock_cache>      <== NOT EXECUTED
4000f6ec:	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)                                             
4000f6f0:	c2 0f 60 0c 	ldub  [ %i5 + 0xc ], %g1                       <== NOT EXECUTED
4000f6f4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000f6f8:	12 bf ff ee 	bne  4000f6b0 <rtems_bdbuf_swapout_worker_task+0x28><== NOT EXECUTED
4000f6fc:	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);                                  
4000f700:	d0 07 60 24 	ld  [ %i5 + 0x24 ], %o0                        <== NOT EXECUTED
4000f704:	7f ff d7 12 	call  4000534c <free>                          <== NOT EXECUTED
4000f708:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  free (worker);                                                      
4000f70c:	7f ff d7 10 	call  4000534c <free>                          <== NOT EXECUTED
4000f710:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  rtems_task_delete (RTEMS_SELF);                                     
4000f714:	7f ff e9 8b 	call  40009d40 <rtems_task_delete>             <== NOT EXECUTED
4000f718:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000f18c <rtems_bdbuf_swapout_write>: * * @param transfer The transfer transaction. */ static void rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer) {
4000f18c:	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;                    
4000f190:	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 );                            
4000f194:	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))                         
4000f198:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000f19c:	02 80 00 4f 	be  4000f2d8 <rtems_bdbuf_swapout_write+0x14c> <== NEVER TAKEN
4000f1a0:	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;                             
4000f1a4:	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;              
4000f1a8:	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;
4000f1ac:	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;     
4000f1b0:	f4 04 20 2c 	ld  [ %l0 + 0x2c ], %i2                        
    bool need_continuous_blocks =                                     
      (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
4000f1b4:	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;              
4000f1b8:	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;
4000f1bc:	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;              
4000f1c0:	c4 22 60 0c 	st  %g2, [ %o1 + 0xc ]                         
    transfer->write_req->bufnum = 0;                                  
4000f1c4:	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;          
4000f1c8:	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))
4000f1cc:	10 80 00 23 	b  4000f258 <rtems_bdbuf_swapout_write+0xcc>   
4000f1d0:	25 10 00 6a 	sethi  %hi(0x4001a800), %l2                    
4000f1d4:	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];
4000f1d8:	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;                                     
4000f1dc:	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;                                 
4000f1e0:	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++;                                
4000f1e4:	b8 01 20 01 	add  %g4, 1, %i4                               
4000f1e8:	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];
4000f1ec:	89 29 20 04 	sll  %g4, 4, %g4                               
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
4000f1f0:	b8 10 00 03 	mov  %g3, %i4                                  
        write = true;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000f1f4:	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;                              
4000f1f8:	9a 10 20 00 	clr  %o5                                       
        write = true;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_blkdev_sg_buffer* buf;                                  
        buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
4000f1fc:	86 02 40 04 	add  %o1, %g4, %g3                             
        transfer->write_req->bufnum++;                                
        buf->user   = bd;                                             
        buf->block  = bd->block;                                      
4000f200:	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;                                             
4000f204:	c2 20 e0 0c 	st  %g1, [ %g3 + 0xc ]                         
        buf->block  = bd->block;                                      
        buf->length = dd->block_size;                                 
4000f208:	de 20 e0 04 	st  %o7, [ %g3 + 4 ]                           
        buf->buffer = bd->buffer;                                     
4000f20c:	f2 20 e0 08 	st  %i1, [ %g3 + 8 ]                           
4000f210:	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) ||                    
4000f214:	80 a7 40 01 	cmp  %i5, %g1                                  
4000f218:	02 80 00 07 	be  4000f234 <rtems_bdbuf_swapout_write+0xa8>  
4000f21c:	84 14 a3 d8 	or  %l2, 0x3d8, %g2                            
4000f220:	c6 02 60 10 	ld  [ %o1 + 0x10 ], %g3                        
4000f224:	c4 00 a0 04 	ld  [ %g2 + 4 ], %g2                           
4000f228:	80 a0 c0 02 	cmp  %g3, %g2                                  
4000f22c:	0a 80 00 1e 	bcs  4000f2a4 <rtems_bdbuf_swapout_write+0x118>
4000f230:	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);
4000f234:	90 10 00 10 	mov  %l0, %o0                                  
4000f238:	7f ff ff 5d 	call  4000efac <rtems_bdbuf_execute_transfer_request>
4000f23c:	94 10 20 00 	clr  %o2                                       
                                                                      
        transfer->write_req->status = RTEMS_RESOURCE_IN_USE;          
4000f240:	d2 06 20 14 	ld  [ %i0 + 0x14 ], %o1                        
4000f244:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000f248:	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))                                   
4000f24c:	80 a7 40 01 	cmp  %i5, %g1                                  
4000f250:	02 80 00 19 	be  4000f2b4 <rtems_bdbuf_swapout_write+0x128> 
4000f254:	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;                            
4000f258:	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 &&    
4000f25c:	80 a4 60 00 	cmp  %l1, 0                                    
                                                                      
  head->next = new_first;                                             
4000f260:	c4 26 00 00 	st  %g2, [ %i0 ]                               
4000f264:	02 bf ff dc 	be  4000f1d4 <rtems_bdbuf_swapout_write+0x48>  
4000f268:	f0 20 a0 04 	st  %i0, [ %g2 + 4 ]                           
4000f26c:	c6 02 60 10 	ld  [ %o1 + 0x10 ], %g3                        
4000f270:	80 a0 e0 00 	cmp  %g3, 0                                    
4000f274:	02 bf ff d9 	be  4000f1d8 <rtems_bdbuf_swapout_write+0x4c>  
4000f278:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
          bd->block != last_block + media_blocks_per_block)           
4000f27c:	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 &&    
4000f280:	80 a0 c0 04 	cmp  %g3, %g4                                  
4000f284:	02 bf ff d5 	be  4000f1d8 <rtems_bdbuf_swapout_write+0x4c>  
4000f288:	9a 10 20 01 	mov  1, %o5                                    
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
4000f28c:	f0 20 60 04 	st  %i0, [ %g1 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
4000f290:	c2 26 00 00 	st  %g1, [ %i0 ]                               
  the_node->next        = before_node;                                
4000f294:	c4 20 40 00 	st  %g2, [ %g1 ]                               
  before_node->previous = the_node;                                   
4000f298:	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;                                                 
4000f29c:	10 bf ff de 	b  4000f214 <rtems_bdbuf_swapout_write+0x88>   
4000f2a0:	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)                                                      
4000f2a4:	12 bf ff e4 	bne  4000f234 <rtems_bdbuf_swapout_write+0xa8> 
4000f2a8:	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))                                   
4000f2ac:	32 bf ff ec 	bne,a   4000f25c <rtems_bdbuf_swapout_write+0xd0><== ALWAYS TAKEN
4000f2b0:	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 &&                                          
4000f2b4:	c2 0e 20 10 	ldub  [ %i0 + 0x10 ], %g1                      
4000f2b8:	80 a0 60 00 	cmp  %g1, 0                                    
4000f2bc:	02 80 00 0c 	be  4000f2ec <rtems_bdbuf_swapout_write+0x160> 
4000f2c0:	01 00 00 00 	nop                                            
        (dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))         
4000f2c4:	d0 04 20 08 	ld  [ %l0 + 8 ], %o0                           
4000f2c8:	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 &&                                          
4000f2cc:	80 88 60 02 	btst  2, %g1                                   
4000f2d0:	32 80 00 04 	bne,a   4000f2e0 <rtems_bdbuf_swapout_write+0x154><== NEVER TAKEN
4000f2d4:	c2 04 20 38 	ld  [ %l0 + 0x38 ], %g1                        <== NOT EXECUTED
4000f2d8:	81 c7 e0 08 	ret                                            
4000f2dc:	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);
4000f2e0:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
4000f2e4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4000f2e8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4000f2ec:	81 c7 e0 08 	ret                                            
4000f2f0:	81 e8 00 00 	restore                                        
                                                                      

4000e1c8 <rtems_bdbuf_swapout_writereq_alloc>: * * @return rtems_blkdev_request* The write reference memory. */ static rtems_blkdev_request* rtems_bdbuf_swapout_writereq_alloc (void) {
4000e1c8:	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)));
4000e1cc:	03 10 00 6a 	sethi  %hi(0x4001a800), %g1                    
4000e1d0:	d0 00 63 dc 	ld  [ %g1 + 0x3dc ], %o0	! 4001abdc <rtems_bdbuf_configuration+0x4>
4000e1d4:	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 =                                   
4000e1d8:	7f ff dd a5 	call  4000586c <malloc>                        
4000e1dc:	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)                                                     
4000e1e0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4000e1e4:	02 80 00 0b 	be  4000e210 <rtems_bdbuf_swapout_writereq_alloc+0x48><== NEVER TAKEN
4000e1e8:	82 10 20 01 	mov  1, %g1                                    
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_REQ_NOMEM);               
                                                                      
  write_req->req = RTEMS_BLKDEV_REQ_WRITE;                            
4000e1ec:	c2 27 40 00 	st  %g1, [ %i5 ]                               
  write_req->done = rtems_bdbuf_transfer_done;                        
4000e1f0:	03 10 00 3d 	sethi  %hi(0x4000f400), %g1                    
4000e1f4:	82 10 63 f0 	or  %g1, 0x3f0, %g1	! 4000f7f0 <rtems_bdbuf_transfer_done>
  write_req->io_task = rtems_task_self ();                            
                                                                      
  return write_req;                                                   
}                                                                     
4000e1f8:	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 ();                            
4000e1fc:	40 00 12 50 	call  40012b3c <rtems_task_self>               
4000e200:	c2 27 60 04 	st  %g1, [ %i5 + 4 ]                           
4000e204:	d0 27 60 14 	st  %o0, [ %i5 + 0x14 ]                        
                                                                      
  return write_req;                                                   
}                                                                     
4000e208:	81 c7 e0 08 	ret                                            
4000e20c:	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);               
4000e210:	7f ff ff 53 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e214:	90 10 20 09 	mov  9, %o0                                    <== NOT EXECUTED
                                                                      

40010200 <rtems_bdbuf_sync>: } rtems_status_code rtems_bdbuf_sync (rtems_bdbuf_buffer *bd) {
40010200:	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)                                                     
40010204:	80 a6 20 00 	cmp  %i0, 0                                    
40010208:	02 80 00 30 	be  400102c8 <rtems_bdbuf_sync+0xc8>           <== NEVER TAKEN
4001020c:	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();                                           
40010210:	7f ff f7 65 	call  4000dfa4 <rtems_bdbuf_lock_cache>        
40010214:	01 00 00 00 	nop                                            
                                                                      
  sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");              
  if (sc != RTEMS_SUCCESSFUL)                                         
    return sc;                                                        
                                                                      
  switch (bd->state)                                                  
40010218:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
4001021c:	80 a2 20 03 	cmp  %o0, 3                                    
40010220:	1a 80 00 04 	bcc  40010230 <rtems_bdbuf_sync+0x30>          <== ALWAYS TAKEN
40010224:	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);
40010228:	7f ff f7 65 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
4001022c:	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)                                                  
40010230:	08 80 00 0b 	bleu  4001025c <rtems_bdbuf_sync+0x5c>         
40010234:	82 10 20 08 	mov  8, %g1                                    
40010238:	80 a2 20 06 	cmp  %o0, 6                                    
4001023c:	12 bf ff fb 	bne  40010228 <rtems_bdbuf_sync+0x28>          <== NEVER TAKEN
40010240:	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);                   
40010244:	7f ff f9 7f 	call  4000e840 <rtems_bdbuf_discard_buffer_after_access>
40010248:	90 10 00 18 	mov  %i0, %o0                                  
  }                                                                   
                                                                      
  if (rtems_bdbuf_tracer)                                             
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
4001024c:	7f ff f7 6c 	call  4000dffc <rtems_bdbuf_unlock_cache>      
40010250:	b0 10 20 00 	clr  %i0                                       
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40010254:	81 c7 e0 08 	ret                                            
40010258:	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;                              
4001025c:	3b 10 00 71 	sethi  %hi(0x4001c400), %i5                    
}                                                                     
                                                                      
static void                                                           
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{                                                                     
  bd->state = state;                                                  
40010260:	c2 26 20 20 	st  %g1, [ %i0 + 0x20 ]                        
40010264:	ba 17 61 8c 	or  %i5, 0x18c, %i5                            
40010268:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
                                                                      
  the_node->next = tail;                                              
4001026c:	84 07 60 5c 	add  %i5, 0x5c, %g2                            
  tail->previous = the_node;                                          
40010270:	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;                                              
40010274:	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)                                                    
40010278:	c4 06 20 24 	ld  [ %i0 + 0x24 ], %g2                        
  tail->previous = the_node;                                          
  old_last->next = the_node;                                          
  the_node->previous = old_last;                                      
4001027c:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
40010280:	80 a0 a0 00 	cmp  %g2, 0                                    
40010284:	12 80 00 13 	bne  400102d0 <rtems_bdbuf_sync+0xd0>          
40010288:	f0 20 40 00 	st  %i0, [ %g1 ]                               
    rtems_bdbuf_wake (&bdbuf_cache.access_waiters);                   
                                                                      
  rtems_bdbuf_wake_swapper ();                                        
4001028c:	7f ff f7 62 	call  4000e014 <rtems_bdbuf_wake_swapper>      
40010290:	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);         
40010294:	13 10 00 71 	sethi  %hi(0x4001c400), %o1                    
40010298:	b8 12 61 f8 	or  %o1, 0x1f8, %i4	! 4001c5f8 <bdbuf_cache+0x6c>
static void                                                           
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)               
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
4001029c:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
400102a0:	80 a2 20 01 	cmp  %o0, 1                                    
400102a4:	0a 80 00 07 	bcs  400102c0 <rtems_bdbuf_sync+0xc0>          <== NEVER TAKEN
400102a8:	80 a2 20 07 	cmp  %o0, 7                                    
400102ac:	28 80 00 10 	bleu,a   400102ec <rtems_bdbuf_sync+0xec>      
400102b0:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
400102b4:	80 a2 20 0a 	cmp  %o0, 0xa                                  
400102b8:	28 80 00 09 	bleu,a   400102dc <rtems_bdbuf_sync+0xdc>      <== ALWAYS TAKEN
400102bc:	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);
400102c0:	7f ff f7 3f 	call  4000dfbc <rtems_bdbuf_fatal_with_state>  <== NOT EXECUTED
400102c4:	92 10 20 15 	mov  0x15, %o1                                 <== NOT EXECUTED
    rtems_bdbuf_show_usage ();                                        
                                                                      
  rtems_bdbuf_unlock_cache ();                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400102c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400102cc:	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);                   
400102d0:	7f ff f7 ec 	call  4000e280 <rtems_bdbuf_wake>              
400102d4:	90 07 60 64 	add  %i5, 0x64, %o0                            
400102d8:	30 bf ff ed 	b,a   4001028c <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);         
400102dc:	7f ff f7 96 	call  4000e134 <rtems_bdbuf_wait>              
400102e0:	92 10 00 1c 	mov  %i4, %o1                                  
static void                                                           
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)               
{                                                                     
  while (true)                                                        
  {                                                                   
    switch (bd->state)                                                
400102e4:	10 bf ff ef 	b  400102a0 <rtems_bdbuf_sync+0xa0>            
400102e8:	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                                                
400102ec:	80 a0 60 00 	cmp  %g1, 0                                    
400102f0:	12 bf ff d7 	bne  4001024c <rtems_bdbuf_sync+0x4c>          
400102f4:	82 02 3f ff 	add  %o0, -1, %g1                              
        && (bd->state == RTEMS_BDBUF_STATE_CACHED                     
400102f8:	80 a0 60 01 	cmp  %g1, 1                                    
400102fc:	18 bf ff d4 	bgu  4001024c <rtems_bdbuf_sync+0x4c>          <== NEVER TAKEN
40010300:	80 a2 20 01 	cmp  %o0, 1                                    
          || bd->state == RTEMS_BDBUF_STATE_EMPTY))                   
  {                                                                   
    if (bd->state == RTEMS_BDBUF_STATE_EMPTY)                         
40010304:	02 80 00 06 	be  4001031c <rtems_bdbuf_sync+0x11c>          
40010308:	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);                   
4001030c:	11 10 00 71 	sethi  %hi(0x4001c400), %o0                    
40010310:	7f ff f7 dc 	call  4000e280 <rtems_bdbuf_wake>              
40010314:	90 12 22 00 	or  %o0, 0x200, %o0	! 4001c600 <bdbuf_cache+0x74>
40010318:	30 bf ff cd 	b,a   4001024c <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);                              
4001031c:	7f ff f8 41 	call  4000e420 <rtems_bdbuf_remove_from_tree>  
40010320:	90 10 00 18 	mov  %i0, %o0                                  
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
40010324:	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;                                                  
40010328:	c0 26 20 20 	clr  [ %i0 + 0x20 ]                            
  after_node->next      = the_node;                                   
4001032c:	f0 27 60 40 	st  %i0, [ %i5 + 0x40 ]                        
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
40010330:	05 10 00 71 	sethi  %hi(0x4001c400), %g2                    
40010334:	84 10 a1 cc 	or  %g2, 0x1cc, %g2	! 4001c5cc <bdbuf_cache+0x40>
40010338:	c4 26 20 04 	st  %g2, [ %i0 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
  the_node->next        = before_node;                                
4001033c:	c2 26 00 00 	st  %g1, [ %i0 ]                               
  before_node->previous = the_node;                                   
40010340:	10 bf ff f3 	b  4001030c <rtems_bdbuf_sync+0x10c>           
40010344:	f0 20 60 04 	st  %i0, [ %g1 + 4 ]                           
                                                                      

4000dfd0 <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) {
4000dfd0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = rtems_semaphore_release (lock);              
4000dfd4:	7f ff ee d2 	call  40009b1c <rtems_semaphore_release>       
4000dfd8:	90 10 00 18 	mov  %i0, %o0                                  
  if (sc != RTEMS_SUCCESSFUL)                                         
4000dfdc:	80 a2 20 00 	cmp  %o0, 0                                    
4000dfe0:	12 80 00 04 	bne  4000dff0 <rtems_bdbuf_unlock+0x20>        <== NEVER TAKEN
4000dfe4:	01 00 00 00 	nop                                            
4000dfe8:	81 c7 e0 08 	ret                                            
4000dfec:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (fatal_error_code);                             
4000dff0:	7f ff ff db 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000dff4:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
                                                                      

4000e180 <rtems_bdbuf_wait_for_event>: return RTEMS_UNSATISFIED; } static void rtems_bdbuf_wait_for_event (rtems_event_set event) {
4000e180:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_event_set   out = 0;                                          
                                                                      
  sc = rtems_event_receive (event,                                    
4000e184:	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;                                          
4000e188:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  sc = rtems_event_receive (event,                                    
4000e18c:	90 10 00 18 	mov  %i0, %o0                                  
4000e190:	94 10 20 00 	clr  %o2                                       
4000e194:	7f ff ec 76 	call  4000936c <rtems_event_receive>           
4000e198:	96 07 bf fc 	add  %fp, -4, %o3                              
                            RTEMS_EVENT_ALL | RTEMS_WAIT,             
                            RTEMS_NO_TIMEOUT,                         
                            &out);                                    
                                                                      
  if (sc != RTEMS_SUCCESSFUL || out != event)                         
4000e19c:	80 a2 20 00 	cmp  %o0, 0                                    
4000e1a0:	12 80 00 07 	bne  4000e1bc <rtems_bdbuf_wait_for_event+0x3c><== NEVER TAKEN
4000e1a4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000e1a8:	80 a0 40 18 	cmp  %g1, %i0                                  
4000e1ac:	12 80 00 04 	bne  4000e1bc <rtems_bdbuf_wait_for_event+0x3c><== NEVER TAKEN
4000e1b0:	01 00 00 00 	nop                                            
4000e1b4:	81 c7 e0 08 	ret                                            
4000e1b8:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT);                  
4000e1bc:	7f ff ff 68 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e1c0:	90 10 20 1c 	mov  0x1c, %o0                                 <== NOT EXECUTED
                                                                      

4000ef74 <rtems_bdbuf_wait_for_transient_event>: rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_EVNT); } static void rtems_bdbuf_wait_for_transient_event (void) {
4000ef74:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_interval ticks                                                
)                                                                     
{                                                                     
  rtems_event_set event_out;                                          
                                                                      
  return rtems_event_system_receive(                                  
4000ef78:	11 20 00 00 	sethi  %hi(0x80000000), %o0                    
4000ef7c:	92 10 20 00 	clr  %o1                                       
4000ef80:	94 10 20 00 	clr  %o2                                       
4000ef84:	40 00 0e 5f 	call  40012900 <rtems_event_system_receive>    
4000ef88:	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)                                         
4000ef8c:	80 a2 20 00 	cmp  %o0, 0                                    
4000ef90:	12 80 00 04 	bne  4000efa0 <rtems_bdbuf_wait_for_transient_event+0x2c><== NEVER TAKEN
4000ef94:	01 00 00 00 	nop                                            
4000ef98:	81 c7 e0 08 	ret                                            
4000ef9c:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_WAIT_TRANS_EVNT);            
4000efa0:	7f ff fb ef 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000efa4:	90 10 20 1d 	mov  0x1d, %o0                                 <== NOT EXECUTED
                                                                      

4000e280 <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) {
4000e280:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (waiters->count > 0)                                             
4000e284:	c2 06 00 00 	ld  [ %i0 ], %g1                               
4000e288:	80 a0 60 00 	cmp  %g1, 0                                    
4000e28c:	12 80 00 04 	bne  4000e29c <rtems_bdbuf_wake+0x1c>          
4000e290:	01 00 00 00 	nop                                            
4000e294:	81 c7 e0 08 	ret                                            
4000e298:	81 e8 00 00 	restore                                        
  {                                                                   
    sc = rtems_semaphore_flush (waiters->sema);                       
4000e29c:	40 00 11 6c 	call  4001284c <rtems_semaphore_flush>         
4000e2a0:	d0 06 20 04 	ld  [ %i0 + 4 ], %o0                           
    if (sc != RTEMS_SUCCESSFUL)                                       
4000e2a4:	80 a2 20 00 	cmp  %o0, 0                                    
4000e2a8:	02 bf ff fb 	be  4000e294 <rtems_bdbuf_wake+0x14>           <== ALWAYS TAKEN
4000e2ac:	01 00 00 00 	nop                                            
      rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_CACHE_WAKE);               
4000e2b0:	7f ff ff 2b 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e2b4:	90 10 20 04 	mov  4, %o0	! 4 <PROM_START+0x4>               <== NOT EXECUTED
                                                                      

4000e014 <rtems_bdbuf_wake_swapper>: } } static void rtems_bdbuf_wake_swapper (void) {
4000e014:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,       
4000e018:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
4000e01c:	d0 00 61 8c 	ld  [ %g1 + 0x18c ], %o0	! 4001c58c <bdbuf_cache>
4000e020:	7f ff ed 37 	call  400094fc <rtems_event_send>              
4000e024:	92 10 20 04 	mov  4, %o1                                    
                                           RTEMS_BDBUF_SWAPOUT_SYNC); 
  if (sc != RTEMS_SUCCESSFUL)                                         
4000e028:	80 a2 20 00 	cmp  %o0, 0                                    
4000e02c:	12 80 00 04 	bne  4000e03c <rtems_bdbuf_wake_swapper+0x28>  <== NEVER TAKEN
4000e030:	01 00 00 00 	nop                                            
4000e034:	81 c7 e0 08 	ret                                            
4000e038:	81 e8 00 00 	restore                                        
    rtems_bdbuf_fatal (RTEMS_BDBUF_FATAL_SO_WAKE_1);                  
4000e03c:	7f ff ff c8 	call  4000df5c <rtems_bdbuf_fatal>             <== NOT EXECUTED
4000e040:	90 10 20 0b 	mov  0xb, %o0                                  <== NOT EXECUTED
                                                                      

400039fc <rtems_bdpart_create>: const rtems_bdpart_format *format, rtems_bdpart_partition *pt, const unsigned *dist, size_t count ) {
400039fc:	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;                                 
40003a00:	80 a6 60 00 	cmp  %i1, 0                                    
40003a04:	02 80 00 06 	be  40003a1c <rtems_bdpart_create+0x20>        <== NEVER TAKEN
40003a08:	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                        
40003a0c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40003a10:	80 a0 60 00 	cmp  %g1, 0                                    
40003a14:	22 80 00 12 	be,a   40003a5c <rtems_bdpart_create+0x60>     <== ALWAYS TAKEN
40003a18:	c2 0e 60 08 	ldub  [ %i1 + 8 ], %g1                         
    && format->mbr.dos_compatibility;                                 
  rtems_blkdev_bnum disk_end = 0;                                     
40003a1c:	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                             
40003a20:	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 =                                    
40003a24:	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) {                                                   
40003a28:	80 a7 20 00 	cmp  %i4, 0                                    
40003a2c:	02 80 00 0a 	be  40003a54 <rtems_bdpart_create+0x58>        <== NEVER TAKEN
40003a30:	b0 10 20 00 	clr  %i0                                       
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || dist == NULL) {                 
40003a34:	80 a6 a0 00 	cmp  %i2, 0                                    
40003a38:	02 80 00 07 	be  40003a54 <rtems_bdpart_create+0x58>        <== NEVER TAKEN
40003a3c:	b0 10 20 09 	mov  9, %i0                                    
40003a40:	80 a6 60 00 	cmp  %i1, 0                                    
40003a44:	02 80 00 04 	be  40003a54 <rtems_bdpart_create+0x58>        <== NEVER TAKEN
40003a48:	80 a6 e0 00 	cmp  %i3, 0                                    
40003a4c:	12 80 00 0a 	bne  40003a74 <rtems_bdpart_create+0x78>       <== ALWAYS TAKEN
40003a50:	92 10 20 00 	clr  %o1                                       
                                                                      
  /* Expand the last partition to the disk end */                     
  pt [count - 1].end = disk_end;                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003a54:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003a58:	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;                                 
40003a5c:	80 a0 60 00 	cmp  %g1, 0                                    
40003a60:	02 bf ff f0 	be  40003a20 <rtems_bdpart_create+0x24>        <== NEVER TAKEN
40003a64:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  const unsigned *dist,                                               
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  bool dos_compatibility = format != NULL                             
40003a68:	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 =                                    
40003a6c:	10 bf ff ef 	b  40003a28 <rtems_bdpart_create+0x2c>         
40003a70:	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); 
40003a74:	94 10 20 00 	clr  %o2                                       
40003a78:	40 00 01 3d 	call  40003f6c <rtems_bdpart_get_disk_data>    
40003a7c:	96 07 bf fc 	add  %fp, -4, %o3                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003a80:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40003a84:	12 80 00 72 	bne  40003c4c <rtems_bdpart_create+0x250>      <== NEVER TAKEN
40003a88:	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];                                             
40003a8c:	e4 06 c0 00 	ld  [ %i3 ], %l2                               
                                                                      
    if (dist_sum < prev_sum) {                                        
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
                                                                      
    if (dist [i] == 0) {                                              
40003a90:	ba 94 a0 00 	orcc  %l2, 0, %i5                              
40003a94:	12 80 00 0b 	bne  40003ac0 <rtems_bdpart_create+0xc4>       <== ALWAYS TAKEN
40003a98:	82 10 20 00 	clr  %g1                                       
      return RTEMS_INVALID_NUMBER;                                    
40003a9c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003aa0:	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];                                             
40003aa4:	c4 06 c0 02 	ld  [ %i3 + %g2 ], %g2                         
40003aa8:	86 07 40 02 	add  %i5, %g2, %g3                             
                                                                      
    if (dist_sum < prev_sum) {                                        
40003aac:	80 a0 c0 1d 	cmp  %g3, %i5                                  
40003ab0:	0a 80 00 0e 	bcs  40003ae8 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
40003ab4:	80 a0 a0 00 	cmp  %g2, 0                                    
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
                                                                      
    if (dist [i] == 0) {                                              
40003ab8:	02 80 00 0c 	be  40003ae8 <rtems_bdpart_create+0xec>        <== NEVER TAKEN
40003abc:	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) {                                       
40003ac0:	82 00 60 01 	inc  %g1                                       
40003ac4:	80 a0 40 1c 	cmp  %g1, %i4                                  
40003ac8:	12 bf ff f7 	bne  40003aa4 <rtems_bdpart_create+0xa8>       
40003acc:	85 28 60 02 	sll  %g1, 2, %g2                               
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
  }                                                                   
                                                                      
  /* Check format */                                                  
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                      
40003ad0:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40003ad4:	80 a0 60 00 	cmp  %g1, 0                                    
40003ad8:	02 80 00 06 	be  40003af0 <rtems_bdpart_create+0xf4>        <== ALWAYS TAKEN
40003adc:	a2 8c 60 ff 	andcc  %l1, 0xff, %l1                          
    return RTEMS_NOT_IMPLEMENTED;                                     
40003ae0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003ae4:	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;                                    
40003ae8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003aec:	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) {                                            
40003af0:	02 80 00 06 	be  40003b08 <rtems_bdpart_create+0x10c>       <== NEVER TAKEN
40003af4:	ec 07 bf fc 	ld  [ %fp + -4 ], %l6                          
    disk_end -= (disk_end % record_space);                            
40003af8:	90 10 00 16 	mov  %l6, %o0                                  
40003afc:	40 00 7d 81 	call  40023100 <.urem>                         
40003b00:	92 10 00 10 	mov  %l0, %o1                                  
40003b04:	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) {                                                    
40003b08:	80 a7 20 04 	cmp  %i4, 4                                    
40003b0c:	08 80 00 06 	bleu  40003b24 <rtems_bdpart_create+0x128>     <== NEVER TAKEN
40003b10:	aa 10 00 10 	mov  %l0, %l5                                  
    overhead += (count - 3) * record_space;                           
40003b14:	90 10 00 10 	mov  %l0, %o0                                  
40003b18:	40 00 7c 94 	call  40022d68 <.umul>                         
40003b1c:	92 07 3f fd 	add  %i4, -3, %o1                              
40003b20:	aa 02 00 10 	add  %o0, %l0, %l5                             
                                                                      
  /*                                                                  
   * Account space to align every partition on cylinder boundaries if 
   * necessary.                                                       
   */                                                                 
  if (dos_compatibility) {                                            
40003b24:	80 a4 60 00 	cmp  %l1, 0                                    
40003b28:	02 80 00 07 	be  40003b44 <rtems_bdpart_create+0x148>       <== NEVER TAKEN
40003b2c:	82 05 40 1c 	add  %l5, %i4, %g1                             
    overhead += (count - 1) * record_space;                           
40003b30:	90 10 00 10 	mov  %l0, %o0                                  
40003b34:	40 00 7c 8d 	call  40022d68 <.umul>                         
40003b38:	92 07 3f ff 	add  %i4, -1, %o1                              
40003b3c:	aa 05 40 08 	add  %l5, %o0, %l5                             
  }                                                                   
                                                                      
  /* Check disk space */                                              
  if ((overhead + count) > disk_end) {                                
40003b40:	82 05 40 1c 	add  %l5, %i4, %g1                             
40003b44:	80 a0 40 16 	cmp  %g1, %l6                                  
40003b48:	08 80 00 04 	bleu  40003b58 <rtems_bdpart_create+0x15c>     <== ALWAYS TAKEN
40003b4c:	aa 25 80 15 	sub  %l6, %l5, %l5                             
    return RTEMS_IO_ERROR;                                            
40003b50:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003b54:	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];                      
40003b58:	92 10 00 12 	mov  %l2, %o1                                  
40003b5c:	40 00 7c 83 	call  40022d68 <.umul>                         
40003b60:	90 10 00 15 	mov  %l5, %o0                                  
    if (s < free_space || s < dist [i]) {                             
40003b64:	80 a5 40 08 	cmp  %l5, %o0                                  
40003b68:	18 bf ff e0 	bgu  40003ae8 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
40003b6c:	80 a4 80 08 	cmp  %l2, %o0                                  
40003b70:	18 bf ff de 	bgu  40003ae8 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
40003b74:	80 a7 20 04 	cmp  %i4, 4                                    
40003b78:	18 80 00 03 	bgu  40003b84 <rtems_bdpart_create+0x188>      <== ALWAYS TAKEN
40003b7c:	ae 10 20 01 	mov  1, %l7                                    
40003b80:	ae 10 20 00 	clr  %l7                                       <== NOT EXECUTED
#endif                                                                
                                                                      
#include <rtems.h>                                                    
#include <rtems/bdpart.h>                                             
                                                                      
rtems_status_code rtems_bdpart_create(                                
40003b84:	a8 06 a0 30 	add  %i2, 0x30, %l4                            
40003b88:	a6 10 00 1a 	mov  %i2, %l3                                  
  if ((overhead + count) > disk_end) {                                
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  /* Begin of first primary partition */                              
  pos = record_space;                                                 
40003b8c:	a2 10 00 10 	mov  %l0, %l1                                  
                                                                      
  /* Space for partitions */                                          
  free_space = disk_end - overhead;                                   
                                                                      
  for (i = 0; i < count; ++i) {                                       
40003b90:	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) {                                         
40003b94:	10 80 00 0b 	b  40003bc0 <rtems_bdpart_create+0x1c4>        
40003b98:	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];                      
40003b9c:	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;                               
40003ba0:	a6 10 00 14 	mov  %l4, %l3                                  
                                                                      
    /* Partition size */                                              
    rtems_blkdev_bnum s = free_space * dist [i];                      
40003ba4:	40 00 7c 71 	call  40022d68 <.umul>                         
40003ba8:	90 10 00 12 	mov  %l2, %o0                                  
    if (s < free_space || s < dist [i]) {                             
40003bac:	80 a5 40 08 	cmp  %l5, %o0                                  
40003bb0:	18 bf ff ce 	bgu  40003ae8 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
40003bb4:	80 a4 80 08 	cmp  %l2, %o0                                  
40003bb8:	18 bf ff cc 	bgu  40003ae8 <rtems_bdpart_create+0xec>       <== NEVER TAKEN
40003bbc:	a8 05 20 30 	add  %l4, 0x30, %l4                            
      /* TODO: Calculate without overflow */                          
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
    s /= dist_sum;                                                    
40003bc0:	40 00 7c a4 	call  40022e50 <.udiv>                         
40003bc4:	92 10 00 1d 	mov  %i5, %o1                                  
    if (s == 0) {                                                     
      s = 1;                                                          
    }                                                                 
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
40003bc8:	92 10 00 10 	mov  %l0, %o1                                  
      return RTEMS_INVALID_NUMBER;                                    
    }                                                                 
    s /= dist_sum;                                                    
                                                                      
    /* Ensure that the partition is not empty */                      
    if (s == 0) {                                                     
40003bcc:	80 a2 20 00 	cmp  %o0, 0                                    
40003bd0:	12 80 00 03 	bne  40003bdc <rtems_bdpart_create+0x1e0>      <== ALWAYS TAKEN
40003bd4:	a4 10 00 08 	mov  %o0, %l2                                  
      s = 1;                                                          
40003bd8:	a4 10 20 01 	mov  1, %l2                                    <== NOT EXECUTED
    }                                                                 
                                                                      
    /* Align partition upwards */                                     
    s += record_space - (s % record_space);                           
40003bdc:	40 00 7d 49 	call  40023100 <.urem>                         
40003be0:	90 10 00 12 	mov  %l2, %o0                                  
40003be4:	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];                      
40003be8:	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) {                                         
40003bec:	82 10 20 01 	mov  1, %g1                                    
40003bf0:	80 a6 60 02 	cmp  %i1, 2                                    
40003bf4:	18 80 00 03 	bgu  40003c00 <rtems_bdpart_create+0x204>      
40003bf8:	90 24 80 08 	sub  %l2, %o0, %o0                             
40003bfc:	82 10 20 00 	clr  %g1                                       
40003c00:	80 88 60 ff 	btst  0xff, %g1                                
40003c04:	22 80 00 06 	be,a   40003c1c <rtems_bdpart_create+0x220>    
40003c08:	e2 24 c0 00 	st  %l1, [ %l3 ]                               
40003c0c:	80 a5 e0 00 	cmp  %l7, 0                                    
40003c10:	32 80 00 02 	bne,a   40003c18 <rtems_bdpart_create+0x21c>   <== ALWAYS TAKEN
40003c14:	a2 04 40 10 	add  %l1, %l0, %l1                             
      pos += record_space;                                            
    }                                                                 
                                                                      
    /* Partition begin and end */                                     
    p->begin = pos;                                                   
40003c18:	e2 24 c0 00 	st  %l1, [ %l3 ]                               
    pos += s;                                                         
40003c1c:	a2 04 40 08 	add  %l1, %o0, %l1                             
    p->end = pos;                                                     
40003c20:	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) {                                       
40003c24:	b2 06 60 01 	inc  %i1                                       
40003c28:	80 a7 00 19 	cmp  %i4, %i1                                  
40003c2c:	18 bf ff dc 	bgu  40003b9c <rtems_bdpart_create+0x1a0>      
40003c30:	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;                                      
40003c34:	b8 07 3f ff 	add  %i4, -1, %i4                              
40003c38:	83 2f 20 04 	sll  %i4, 4, %g1                               
40003c3c:	b9 2f 20 06 	sll  %i4, 6, %i4                               
40003c40:	82 27 00 01 	sub  %i4, %g1, %g1                             
40003c44:	b4 06 80 01 	add  %i2, %g1, %i2                             
40003c48:	ec 26 a0 04 	st  %l6, [ %i2 + 4 ]                           
40003c4c:	81 c7 e0 08 	ret                                            
40003c50:	81 e8 00 00 	restore                                        
                                                                      

40003c54 <rtems_bdpart_dump>: { uuid_unparse_lower( type, str); } void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count) {
40003c54:	9d e3 bf 60 	save  %sp, -160, %sp                           
  size_t i = 0;                                                       
                                                                      
  printf(                                                             
40003c58:	11 10 00 99 	sethi  %hi(0x40026400), %o0                    
40003c5c:	40 00 4d 83 	call  40017268 <puts>                          
40003c60:	90 12 21 28 	or  %o0, 0x128, %o0	! 40026528 <Callbacks.6428+0x178>
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
40003c64:	80 a6 60 00 	cmp  %i1, 0                                    
40003c68:	02 80 00 3a 	be  40003d50 <rtems_bdpart_dump+0xfc>          <== NEVER TAKEN
40003c6c:	11 10 00 99 	sethi  %hi(0x40026400), %o0                    
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40003c70:	29 10 00 99 	sethi  %hi(0x40026400), %l4                    
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
40003c74:	37 10 00 99 	sethi  %hi(0x40026400), %i3                    
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
40003c78:	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";                                            
40003c7c:	2b 10 00 99 	sethi  %hi(0x40026400), %l5                    
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40003c80:	a8 15 22 68 	or  %l4, 0x268, %l4                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16_LBA:                             
          type = "FAT 16 LBA";                                        
40003c84:	27 10 00 99 	sethi  %hi(0x40026400), %l3                    
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
40003c88:	25 10 00 99 	sethi  %hi(0x40026400), %l2                    
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32:                                 
          type = "FAT 32";                                            
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_32_LBA:                             
          type = "FAT 32 LBA";                                        
40003c8c:	23 10 00 99 	sethi  %hi(0x40026400), %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";                                            
40003c90:	21 10 00 99 	sethi  %hi(0x40026400), %l0                    
          break;                                                      
        case RTEMS_BDPART_MBR_FAT_16:                                 
          type = "FAT 16";                                            
40003c94:	35 10 00 99 	sethi  %hi(0x40026400), %i2                    
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
40003c98:	10 80 00 19 	b  40003cfc <rtems_bdpart_dump+0xa8>           
40003c9c:	b6 16 e2 70 	or  %i3, 0x270, %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) {                                             
40003ca0:	80 a2 e0 0b 	cmp  %o3, 0xb                                  
40003ca4:	22 80 00 0e 	be,a   40003cdc <rtems_bdpart_dump+0x88>       <== ALWAYS TAKEN
40003ca8:	96 15 61 10 	or  %l5, 0x110, %o3                            
40003cac:	18 80 00 2d 	bgu  40003d60 <rtems_bdpart_dump+0x10c>        <== NOT EXECUTED
40003cb0:	80 a2 e0 0e 	cmp  %o3, 0xe                                  <== NOT EXECUTED
40003cb4:	80 a2 e0 01 	cmp  %o3, 1                                    <== NOT EXECUTED
40003cb8:	02 80 00 36 	be  40003d90 <rtems_bdpart_dump+0x13c>         <== NOT EXECUTED
40003cbc:	80 a2 e0 04 	cmp  %o3, 4                                    <== NOT EXECUTED
40003cc0:	22 80 00 07 	be,a   40003cdc <rtems_bdpart_dump+0x88>       <== NOT EXECUTED
40003cc4:	96 16 a0 e8 	or  %i2, 0xe8, %o3                             <== NOT EXECUTED
          break;                                                      
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
        default:                                                      
          snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
40003cc8:	90 07 bf c8 	add  %fp, -56, %o0                             <== NOT EXECUTED
40003ccc:	92 10 20 34 	mov  0x34, %o1                                 <== NOT EXECUTED
40003cd0:	40 00 4d a0 	call  40017350 <snprintf>                      <== NOT EXECUTED
40003cd4:	94 10 00 14 	mov  %l4, %o2                                  <== NOT EXECUTED
          type = type_buffer;                                         
40003cd8:	96 07 bf c8 	add  %fp, -56, %o3                             <== NOT EXECUTED
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
40003cdc:	d2 06 00 00 	ld  [ %i0 ], %o1                               
40003ce0:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
40003ce4:	40 00 4d 2b 	call  40017190 <printf>                        
40003ce8:	90 10 00 1b 	mov  %i3, %o0                                  
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
40003cec:	ba 07 60 01 	inc  %i5                                       
40003cf0:	80 a7 40 19 	cmp  %i5, %i1                                  
40003cf4:	02 80 00 16 	be  40003d4c <rtems_bdpart_dump+0xf8>          
40003cf8:	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;                                             
40003cfc:	c0 2f bf c7 	clrb  [ %fp + -57 ]                            
                                                                      
    if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {    
40003d00:	b8 06 20 08 	add  %i0, 8, %i4                               
40003d04:	92 07 bf c7 	add  %fp, -57, %o1                             
40003d08:	40 00 00 8d 	call  40003f3c <rtems_bdpart_to_mbr_partition_type>
40003d0c:	90 10 00 1c 	mov  %i4, %o0                                  
40003d10:	80 8a 20 ff 	btst  0xff, %o0                                
40003d14:	12 bf ff e3 	bne  40003ca0 <rtems_bdpart_dump+0x4c>         <== ALWAYS TAKEN
40003d18:	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);                                     
40003d1c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40003d20:	40 00 2c d2 	call  4000f068 <uuid_unparse_lower>            <== NOT EXECUTED
40003d24:	92 07 bf c8 	add  %fp, -56, %o1                             <== NOT EXECUTED
    } else {                                                          
      rtems_bdpart_type_to_string( p->type, type_buffer);             
      type = type_buffer;                                             
    }                                                                 
                                                                      
    printf(                                                           
40003d28:	d2 06 00 00 	ld  [ %i0 ], %o1                               <== NOT EXECUTED
40003d2c:	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;                                             
40003d30:	96 07 bf c8 	add  %fp, -56, %o3                             <== NOT EXECUTED
    }                                                                 
                                                                      
    printf(                                                           
40003d34:	40 00 4d 17 	call  40017190 <printf>                        <== NOT EXECUTED
40003d38:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    "------------+------------+-----------------------------------------------------\n"
    " BEGIN      | END        | TYPE\n"                               
    "------------+------------+-----------------------------------------------------\n"
  );                                                                  
                                                                      
  for (i = 0; i < count; ++i) {                                       
40003d3c:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40003d40:	80 a7 40 19 	cmp  %i5, %i1                                  <== NOT EXECUTED
40003d44:	12 bf ff ee 	bne  40003cfc <rtems_bdpart_dump+0xa8>         <== NOT EXECUTED
40003d48:	b0 06 20 30 	add  %i0, 0x30, %i0                            <== NOT EXECUTED
      p->end,                                                         
      type                                                            
    );                                                                
  }                                                                   
                                                                      
  puts( "------------+------------+-----------------------------------------------------");
40003d4c:	11 10 00 99 	sethi  %hi(0x40026400), %o0                    
40003d50:	40 00 4d 46 	call  40017268 <puts>                          
40003d54:	90 12 22 18 	or  %o0, 0x218, %o0	! 40026618 <Callbacks.6428+0x268>
40003d58:	81 c7 e0 08 	ret                                            
40003d5c:	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) {                                             
40003d60:	02 80 00 0a 	be  40003d88 <rtems_bdpart_dump+0x134>         <== NOT EXECUTED
40003d64:	80 a2 e0 da 	cmp  %o3, 0xda                                 <== NOT EXECUTED
40003d68:	02 80 00 06 	be  40003d80 <rtems_bdpart_dump+0x12c>         <== NOT EXECUTED
40003d6c:	80 a2 e0 0c 	cmp  %o3, 0xc                                  <== NOT EXECUTED
40003d70:	12 bf ff d7 	bne  40003ccc <rtems_bdpart_dump+0x78>         <== NOT EXECUTED
40003d74:	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;                                                      
40003d78:	10 bf ff d9 	b  40003cdc <rtems_bdpart_dump+0x88>           <== NOT EXECUTED
40003d7c:	96 14 61 00 	or  %l1, 0x100, %o3                            <== NOT EXECUTED
        case RTEMS_BDPART_MBR_DATA:                                   
          type = "DATA";                                              
          break;                                                      
40003d80:	10 bf ff d7 	b  40003cdc <rtems_bdpart_dump+0x88>           <== NOT EXECUTED
40003d84:	96 14 a0 f8 	or  %l2, 0xf8, %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;                                                      
40003d88:	10 bf ff d5 	b  40003cdc <rtems_bdpart_dump+0x88>           <== NOT EXECUTED
40003d8c:	96 14 e1 18 	or  %l3, 0x118, %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";                                            
40003d90:	10 bf ff d3 	b  40003cdc <rtems_bdpart_dump+0x88>           <== NOT EXECUTED
40003d94:	96 14 20 f0 	or  %l0, 0xf0, %o3                             <== NOT EXECUTED
                                                                      

40003f6c <rtems_bdpart_get_disk_data>: const char *disk_name, int *fd_ptr, rtems_disk_device **dd_ptr, rtems_blkdev_bnum *disk_end ) {
40003f6c:	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);                                      
40003f70:	92 10 20 02 	mov  2, %o1                                    
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  int rv = 0;                                                         
  int fd = -1;                                                        
  rtems_disk_device *dd = NULL;                                       
40003f74:	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);                                      
40003f78:	40 00 0d 2a 	call  40007420 <open>                          
40003f7c:	90 10 00 18 	mov  %i0, %o0                                  
  if (fd < 0) {                                                       
40003f80:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40003f84:	16 80 00 07 	bge  40003fa0 <rtems_bdpart_get_disk_data+0x34><== ALWAYS TAKEN
40003f88:	94 07 bf fc 	add  %fp, -4, %o2                              
    sc = RTEMS_INVALID_NAME;                                          
40003f8c:	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);                                                       
40003f90:	40 00 09 50 	call  400064d0 <close>                         <== NOT EXECUTED
40003f94:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40003f98:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003f9c:	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);                   
40003fa0:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
40003fa4:	40 00 09 ed 	call  40006758 <ioctl>                         
40003fa8:	92 12 62 09 	or  %o1, 0x209, %o1	! 40044209 <__end+0x1b119> 
    goto error;                                                       
  }                                                                   
                                                                      
  /* Get disk handle */                                               
  rv = rtems_disk_fd_get_disk_device( fd, &dd);                       
  if (rv != 0) {                                                      
40003fac:	80 a2 20 00 	cmp  %o0, 0                                    
40003fb0:	32 bf ff f8 	bne,a   40003f90 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40003fb4:	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;                                             
40003fb8:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  *disk_end = dd->size;                                               
40003fbc:	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;                                             
40003fc0:	c6 00 60 18 	ld  [ %g1 + 0x18 ], %g3                        
  *disk_end = dd->size;                                               
40003fc4:	c4 26 c0 00 	st  %g2, [ %i3 ]                               
  block_size = dd->block_size;                                        
                                                                      
  /* Check block size */                                              
  if (block_size < RTEMS_BDPART_BLOCK_SIZE) {                         
40003fc8:	c4 00 60 24 	ld  [ %g1 + 0x24 ], %g2                        
40003fcc:	80 a0 a1 ff 	cmp  %g2, 0x1ff                                
40003fd0:	08 bf ff f0 	bleu  40003f90 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40003fd4:	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) {                                              
40003fd8:	80 a0 e0 00 	cmp  %g3, 0                                    
40003fdc:	12 bf ff ed 	bne  40003f90 <rtems_bdpart_get_disk_data+0x24><== NEVER TAKEN
40003fe0:	80 a6 60 00 	cmp  %i1, 0                                    
    goto error;                                                       
  }                                                                   
                                                                      
error:                                                                
                                                                      
  if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {   
40003fe4:	02 80 00 08 	be  40004004 <rtems_bdpart_get_disk_data+0x98> 
40003fe8:	80 a6 a0 00 	cmp  %i2, 0                                    
40003fec:	02 80 00 07 	be  40004008 <rtems_bdpart_get_disk_data+0x9c> <== NEVER TAKEN
40003ff0:	b0 10 20 00 	clr  %i0                                       
    *fd_ptr = fd;                                                     
40003ff4:	fa 26 40 00 	st  %i5, [ %i1 ]                               
    *dd_ptr = dd;                                                     
40003ff8:	c2 26 80 00 	st  %g1, [ %i2 ]                               
40003ffc:	81 c7 e0 08 	ret                                            
40004000:	81 e8 00 00 	restore                                        
  int *fd_ptr,                                                        
  rtems_disk_device **dd_ptr,                                         
  rtems_blkdev_bnum *disk_end                                         
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
40004004:	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);                                                       
40004008:	40 00 09 32 	call  400064d0 <close>                         
4000400c:	90 10 00 1d 	mov  %i5, %o0                                  
40004010:	81 c7 e0 08 	ret                                            
40004014:	81 e8 00 00 	restore                                        
                                                                      

40025100 <rtems_bdpart_mount>: const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count, const char *mount_base ) {
40025100:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
40025104:	92 10 20 2f 	mov  0x2f, %o1                                 <== NOT EXECUTED
40025108:	40 00 7d 89 	call  4004472c <strrchr>                       <== NOT EXECUTED
4002510c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40025110:	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);                         
40025114:	40 00 79 63 	call  400436a0 <strlen>                        <== NOT EXECUTED
40025118:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4002511c:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);                       
40025120:	40 00 79 60 	call  400436a0 <strlen>                        <== NOT EXECUTED
40025124:	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                                              
)                                                                     
{                                                                     
40025128:	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);                       
4002512c:	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;                                           
40025130:	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);
40025134:	7f ff 7b e9 	call  400040d8 <malloc>                        <== NOT EXECUTED
40025138:	90 04 20 04 	add  %l0, 4, %o0                               <== NOT EXECUTED
  if (logical_disk_name == NULL) {                                    
4002513c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40025140:	02 80 00 4f 	be  4002527c <rtems_bdpart_mount+0x17c>        <== NOT EXECUTED
40025144:	b2 10 00 08 	mov  %o0, %i1                                  <== NOT EXECUTED
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
40025148:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4002514c:	40 00 7a 11 	call  40043990 <strncpy>                       <== NOT EXECUTED
40025150:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
                                                                      
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
40025154:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40025158:	02 80 00 06 	be  40025170 <rtems_bdpart_mount+0x70>         <== NOT EXECUTED
4002515c:	a6 10 00 10 	mov  %l0, %l3                                  <== NOT EXECUTED
    disk_file_name += 1;                                              
40025160:	ba 07 20 01 	add  %i4, 1, %i5                               <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);                    
40025164:	40 00 79 4f 	call  400436a0 <strlen>                        <== NOT EXECUTED
40025168:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4002516c:	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);
40025170:	a4 04 c0 11 	add  %l3, %l1, %l2                             <== NOT EXECUTED
  if (mount_point == NULL) {                                          
    esc = RTEMS_NO_MEMORY;                                            
40025174:	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);
40025178:	7f ff 7b d8 	call  400040d8 <malloc>                        <== NOT EXECUTED
4002517c:	90 04 a0 05 	add  %l2, 5, %o0                               <== NOT EXECUTED
  if (mount_point == NULL) {                                          
40025180:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40025184:	02 80 00 3a 	be  4002526c <rtems_bdpart_mount+0x16c>        <== NOT EXECUTED
40025188:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
4002518c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40025190:	40 00 7a 00 	call  40043990 <strncpy>                       <== NOT EXECUTED
40025194:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
  mount_point [mount_base_size] = '/';                                
40025198:	82 10 20 2f 	mov  0x2f, %g1                                 <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
4002519c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400251a0:	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] = '/';                                
400251a4:	c2 2f 00 11 	stb  %g1, [ %i4 + %l1 ]                        <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
400251a8:	90 07 00 08 	add  %i4, %o0, %o0                             <== NOT EXECUTED
400251ac:	40 00 79 f9 	call  40043990 <strncpy>                       <== NOT EXECUTED
400251b0:	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;
400251b4:	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;           
400251b8:	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) {                                       
400251bc:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
400251c0:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
400251c4:	02 80 00 29 	be  40025268 <rtems_bdpart_mount+0x168>        <== NOT EXECUTED
400251c8:	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);
400251cc:	21 10 01 86 	sethi  %hi(0x40061800), %l0                    <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Mount */                                                       
    rv = mount(                                                       
400251d0:	23 10 01 7e 	sethi  %hi(0x4005f800), %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);
400251d4:	a0 14 21 08 	or  %l0, 0x108, %l0                            <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Mount */                                                       
    rv = mount(                                                       
400251d8:	10 80 00 04 	b  400251e8 <rtems_bdpart_mount+0xe8>          <== NOT EXECUTED
400251dc:	a2 14 62 20 	or  %l1, 0x220, %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) {                                       
400251e0:	22 80 00 23 	be,a   4002526c <rtems_bdpart_mount+0x16c>     <== NOT EXECUTED
400251e4:	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);
400251e8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400251ec:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
400251f0:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
400251f4:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
400251f8:	40 00 75 b2 	call  400428c0 <snprintf>                      <== NOT EXECUTED
400251fc:	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);
40025200:	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) {                             
40025204:	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);
40025208:	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) {                             
4002520c:	14 80 00 1e 	bg  40025284 <rtems_bdpart_mount+0x184>        <== NOT EXECUTED
40025210:	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);
40025214:	40 00 79 df 	call  40043990 <strncpy>                       <== NOT EXECUTED
40025218:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);      
4002521c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40025220:	40 00 0f e7 	call  400291bc <rtems_mkdir>                   <== NOT EXECUTED
40025224:	92 10 21 ff 	mov  0x1ff, %o1                                <== NOT EXECUTED
    if (rv != 0) {                                                    
40025228:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4002522c:	12 80 00 1c 	bne  4002529c <rtems_bdpart_mount+0x19c>       <== NOT EXECUTED
40025230:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Mount */                                                       
    rv = mount(                                                       
40025234:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
40025238:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
4002523c:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
40025240:	7f ff 7c 2c 	call  400042f0 <mount>                         <== NOT EXECUTED
40025244:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
      mount_point,                                                    
      "msdos",                                                        
      0,                                                              
      NULL                                                            
    );                                                                
    if (rv != 0) {                                                    
40025248:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4002524c:	02 bf ff e5 	be  400251e0 <rtems_bdpart_mount+0xe0>         <== NOT EXECUTED
40025250:	80 a7 40 1a 	cmp  %i5, %i2                                  <== NOT EXECUTED
      rmdir( mount_point);                                            
40025254:	40 00 0f ae 	call  4002910c <rmdir>                         <== NOT EXECUTED
40025258:	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) {                                       
4002525c:	80 a7 40 1a 	cmp  %i5, %i2                                  <== NOT EXECUTED
40025260:	12 bf ff e3 	bne  400251ec <rtems_bdpart_mount+0xec>        <== NOT EXECUTED
40025264:	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;                           
40025268:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
4002526c:	7f ff 7a c1 	call  40003d70 <free>                          <== NOT EXECUTED
40025270:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
  free( mount_point);                                                 
40025274:	7f ff 7a bf 	call  40003d70 <free>                          <== NOT EXECUTED
40025278:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
4002527c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40025280:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
40025284:	7f ff 7a bb 	call  40003d70 <free>                          <== NOT EXECUTED
40025288:	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;                                       
4002528c:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
  free( mount_point);                                                 
40025290:	7f ff 7a b8 	call  40003d70 <free>                          <== NOT EXECUTED
40025294:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40025298:	30 bf ff f9 	b,a   4002527c <rtems_bdpart_mount+0x17c>      <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
4002529c:	7f ff 7a b5 	call  40003d70 <free>                          <== NOT EXECUTED
400252a0:	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;                                           
400252a4:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
  free( mount_point);                                                 
400252a8:	7f ff 7a b2 	call  40003d70 <free>                          <== NOT EXECUTED
400252ac:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
400252b0:	30 bf ff f3 	b,a   4002527c <rtems_bdpart_mount+0x17c>      <== NOT EXECUTED
                                                                      

4000448c <rtems_bdpart_new_record>: static rtems_status_code rtems_bdpart_new_record( rtems_disk_device *dd, rtems_blkdev_bnum index, rtems_bdbuf_buffer **block ) {
4000448c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Synchronize previous block if necessary */                       
  if (*block != NULL) {                                               
40004490:	d0 06 80 00 	ld  [ %i2 ], %o0                               
40004494:	80 a2 20 00 	cmp  %o0, 0                                    
40004498:	22 80 00 07 	be,a   400044b4 <rtems_bdpart_new_record+0x28> 
4000449c:	90 10 00 18 	mov  %i0, %o0                                  
    sc = rtems_bdbuf_sync( *block);                                   
400044a0:	40 00 34 2c 	call  40011550 <rtems_bdbuf_sync>              
400044a4:	01 00 00 00 	nop                                            
    if (sc != RTEMS_SUCCESSFUL) {                                     
400044a8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400044ac:	12 80 00 17 	bne  40004508 <rtems_bdpart_new_record+0x7c>   <== NEVER TAKEN
400044b0:	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);                           
400044b4:	92 10 00 19 	mov  %i1, %o1                                  
400044b8:	40 00 33 49 	call  400111dc <rtems_bdbuf_read>              
400044bc:	94 10 00 1a 	mov  %i2, %o2                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
400044c0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400044c4:	12 80 00 11 	bne  40004508 <rtems_bdpart_new_record+0x7c>   <== NEVER TAKEN
400044c8:	01 00 00 00 	nop                                            
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
400044cc:	c2 06 80 00 	ld  [ %i2 ], %g1                               
400044d0:	80 a0 60 00 	cmp  %g1, 0                                    
400044d4:	02 80 00 0f 	be  40004510 <rtems_bdpart_new_record+0x84>    <== NEVER TAKEN
400044d8:	92 10 20 00 	clr  %o1                                       
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Clear record */                                                  
  memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);              
400044dc:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
400044e0:	40 00 4a d9 	call  40017044 <memset>                        
400044e4:	94 10 22 00 	mov  0x200, %o2                                
                                                                      
  /* Write signature */                                               
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =            
400044e8:	c2 06 80 00 	ld  [ %i2 ], %g1                               
400044ec:	84 10 20 55 	mov  0x55, %g2                                 
400044f0:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
400044f4:	c4 28 61 fe 	stb  %g2, [ %g1 + 0x1fe ]                      
    RTEMS_BDPART_MBR_SIGNATURE_0;                                     
  (*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =            
400044f8:	c2 06 80 00 	ld  [ %i2 ], %g1                               
400044fc:	84 10 3f aa 	mov  -86, %g2                                  
40004500:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
40004504:	c4 28 61 ff 	stb  %g2, [ %g1 + 0x1ff ]                      
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40004508:	81 c7 e0 08 	ret                                            
4000450c:	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;                                     
40004510:	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;                                            
}                                                                     
40004514:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004518:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
                                                                      

40004018 <rtems_bdpart_read>: const char *disk_name, rtems_bdpart_format *format, rtems_bdpart_partition *pt, size_t *count ) {
40004018:	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;                                 
4000401c:	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;                                   
40004020:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
  rtems_bdpart_partition *p = pt - 1;                                 
  const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
40004024:	80 a6 e0 00 	cmp  %i3, 0                                    
40004028:	02 80 00 0a 	be  40004050 <rtems_bdpart_read+0x38>          <== NEVER TAKEN
4000402c:	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;                                                        
40004030:	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 */      
40004034:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
  rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */   
  rtems_blkdev_bnum disk_end = 0;                                     
40004038:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  size_t i = 0;                                                       
  const uint8_t *data = NULL;                                         
  int fd = -1;                                                        
4000403c:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
40004040:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL || count == NULL) {                
40004044:	80 a6 a0 00 	cmp  %i2, 0                                    
40004048:	12 80 00 04 	bne  40004058 <rtems_bdpart_read+0x40>         <== ALWAYS TAKEN
4000404c:	fa 06 c0 00 	ld  [ %i3 ], %i5                               
    return RTEMS_INVALID_ADDRESS;                                     
40004050:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004054:	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) {                
40004058:	80 a6 60 00 	cmp  %i1, 0                                    
4000405c:	02 bf ff fd 	be  40004050 <rtems_bdpart_read+0x38>          <== NEVER TAKEN
40004060:	90 10 00 18 	mov  %i0, %o0                                  
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Set count to a save value */                                     
  *count = 0;                                                         
40004064:	c0 26 c0 00 	clr  [ %i3 ]                                   
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
40004068:	92 07 bf f8 	add  %fp, -8, %o1                              
4000406c:	94 07 bf fc 	add  %fp, -4, %o2                              
40004070:	7f ff ff bf 	call  40003f6c <rtems_bdpart_get_disk_data>    
40004074:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004078:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000407c:	12 80 00 14 	bne  400040cc <rtems_bdpart_read+0xb4>         <== NEVER TAKEN
40004080:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
    return sc;                                                        
  }                                                                   
                                                                      
  /* Read MBR */                                                      
  sc = rtems_bdpart_read_record( dd, 0, &block);                      
40004084:	92 10 20 00 	clr  %o1                                       
40004088:	7f ff ff 44 	call  40003d98 <rtems_bdpart_read_record>      
4000408c:	94 07 bf e8 	add  %fp, -24, %o2                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004090:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40004094:	02 80 00 10 	be  400040d4 <rtems_bdpart_read+0xbc>          <== ALWAYS TAKEN
40004098:	c4 07 bf e8 	ld  [ %fp + -24 ], %g2                         
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
                                                                      
cleanup:                                                              
                                                                      
  if (fd >= 0) {                                                      
4000409c:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
400040a0:	80 a2 20 00 	cmp  %o0, 0                                    
400040a4:	26 80 00 05 	bl,a   400040b8 <rtems_bdpart_read+0xa0>       <== NEVER TAKEN
400040a8:	d0 07 bf e8 	ld  [ %fp + -24 ], %o0                         <== NOT EXECUTED
    close( fd);                                                       
400040ac:	40 00 09 09 	call  400064d0 <close>                         
400040b0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  if (block != NULL) {                                                
400040b4:	d0 07 bf e8 	ld  [ %fp + -24 ], %o0                         
400040b8:	80 a2 20 00 	cmp  %o0, 0                                    
400040bc:	02 80 00 04 	be  400040cc <rtems_bdpart_read+0xb4>          <== NEVER TAKEN
400040c0:	01 00 00 00 	nop                                            
    rtems_bdbuf_release( block);                                      
400040c4:	40 00 34 cb 	call  400113f0 <rtems_bdbuf_release>           
400040c8:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
400040cc:	81 c7 e0 08 	ret                                            
400040d0:	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);
400040d4:	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;             
400040d8:	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);
400040dc:	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;             
400040e0:	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);
400040e4:	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);  
400040e8:	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);
400040ec:	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);  
400040f0:	92 07 bf ec 	add  %fp, -20, %o1                             
400040f4:	94 10 00 1c 	mov  %i4, %o2                                  
400040f8:	7f ff ff 54 	call  40003e48 <rtems_bdpart_read_mbr_partition>
400040fc:	96 07 bf f0 	add  %fp, -16, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004100:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40004104:	32 bf ff e7 	bne,a   400040a0 <rtems_bdpart_read+0x88>      <== NEVER TAKEN
40004108:	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) {
4000410c:	c2 07 bf ec 	ld  [ %fp + -20 ], %g1                         
40004110:	c2 08 60 08 	ldub  [ %g1 + 8 ], %g1                         
40004114:	80 a0 60 ee 	cmp  %g1, 0xee                                 
40004118:	02 bf ff e1 	be  4000409c <rtems_bdpart_read+0x84>          <== NEVER TAKEN
4000411c:	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                   
40004120:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
    esc = RTEMS_NOT_IMPLEMENTED;                                      
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Set format */                                                    
  format->type = RTEMS_BDPART_FORMAT_MBR;                             
40004124:	c0 26 40 00 	clr  [ %i1 ]                                   
  format->mbr.disk_id = rtems_uint32_from_little_endian(              
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
40004128:	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;                                                 
4000412c:	84 10 20 00 	clr  %g2                                       
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_read(                                  
40004130:	82 01 21 bb 	add  %g4, 0x1bb, %g1                           
40004134:	88 01 21 b7 	add  %g4, 0x1b7, %g4                           
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
    value = (value << 8) + data [i];                                  
40004138:	c6 08 40 00 	ldub  [ %g1 ], %g3                             
4000413c:	85 28 a0 08 	sll  %g2, 8, %g2                               
40004140:	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) {                                          
40004144:	80 a0 40 04 	cmp  %g1, %g4                                  
40004148:	12 bf ff fc 	bne  40004138 <rtems_bdpart_read+0x120>        
4000414c:	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;                               
40004150:	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(              
40004154:	c4 26 60 04 	st  %g2, [ %i1 + 4 ]                           
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
  );                                                                  
  format->mbr.dos_compatibility = true;                               
40004158:	c2 2e 60 08 	stb  %g1, [ %i1 + 8 ]                          
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_read(                                  
4000415c:	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;                        
40004160:	a0 04 20 10 	add  %l0, 0x10, %l0                            
                                                                      
    sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
40004164:	92 07 bf ec 	add  %fp, -20, %o1                             
40004168:	90 10 00 10 	mov  %l0, %o0                                  
4000416c:	94 10 00 1c 	mov  %i4, %o2                                  
40004170:	7f ff ff 36 	call  40003e48 <rtems_bdpart_read_mbr_partition>
40004174:	96 07 bf f0 	add  %fp, -16, %o3                             
    if (sc != RTEMS_SUCCESSFUL) {                                     
40004178:	80 a2 20 00 	cmp  %o0, 0                                    
4000417c:	12 80 00 4a 	bne  400042a4 <rtems_bdpart_read+0x28c>        <== NEVER TAKEN
40004180:	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) {                                           
40004184:	32 bf ff f8 	bne,a   40004164 <rtems_bdpart_read+0x14c>     
40004188:	a0 04 20 10 	add  %l0, 0x10, %l0                            
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Iterate through the logical partitions within the extended partition */
  ebr = ep_begin;                                                     
4000418c:	fa 07 bf f0 	ld  [ %fp + -16 ], %i5                         
  while (ebr != 0) {                                                  
40004190:	80 a7 60 00 	cmp  %i5, 0                                    
40004194:	02 80 00 2c 	be  40004244 <rtems_bdpart_read+0x22c>         <== NEVER TAKEN
40004198:	c8 07 bf ec 	ld  [ %fp + -20 ], %g4                         
    rtems_blkdev_bnum tmp = 0;                                        
                                                                      
    /* Read EBR */                                                    
    sc = rtems_bdpart_read_record( dd, ebr, &block);                  
4000419c:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
400041a0:	92 10 00 1d 	mov  %i5, %o1                                  
400041a4:	7f ff fe fd 	call  40003d98 <rtems_bdpart_read_record>      
400041a8:	94 07 bf e8 	add  %fp, -24, %o2                             
    if (sc != RTEMS_SUCCESSFUL) {                                     
400041ac:	80 a2 20 00 	cmp  %o0, 0                                    
400041b0:	12 80 00 3d 	bne  400042a4 <rtems_bdpart_read+0x28c>        <== NEVER TAKEN
400041b4:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read first partition entry */                                  
    sc = rtems_bdpart_read_mbr_partition(                             
400041b8:	92 07 bf ec 	add  %fp, -20, %o1                             
400041bc:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
400041c0:	94 10 00 1c 	mov  %i4, %o2                                  
400041c4:	90 02 21 be 	add  %o0, 0x1be, %o0                           
400041c8:	7f ff ff 20 	call  40003e48 <rtems_bdpart_read_mbr_partition>
400041cc:	96 10 20 00 	clr  %o3                                       
      block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,                
      &p,                                                             
      p_end,                                                          
      NULL                                                            
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
400041d0:	80 a2 20 00 	cmp  %o0, 0                                    
400041d4:	12 80 00 34 	bne  400042a4 <rtems_bdpart_read+0x28c>        <== NEVER TAKEN
400041d8:	c8 07 bf ec 	ld  [ %fp + -20 ], %g4                         
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Adjust partition begin */                                      
    tmp = p->begin + ebr;                                             
400041dc:	c2 01 00 00 	ld  [ %g4 ], %g1                               
400041e0:	84 07 40 01 	add  %i5, %g1, %g2                             
    if (tmp > p->begin) {                                             
400041e4:	80 a0 40 02 	cmp  %g1, %g2                                  
400041e8:	3a bf ff ad 	bcc,a   4000409c <rtems_bdpart_read+0x84>      <== NEVER TAKEN
400041ec:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
      esc = RTEMS_IO_ERROR;                                           
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Adjust partition end */                                        
    tmp = p->end + ebr;                                               
400041f0:	c2 01 20 04 	ld  [ %g4 + 4 ], %g1                           
400041f4:	ba 07 40 01 	add  %i5, %g1, %i5                             
    if (tmp > p->end) {                                               
400041f8:	80 a0 40 1d 	cmp  %g1, %i5                                  
400041fc:	1a 80 00 28 	bcc  4000429c <rtems_bdpart_read+0x284>        <== NEVER TAKEN
40004200:	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                 
40004204:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
    }                                                                 
                                                                      
    /* Adjust partition end */                                        
    tmp = p->end + ebr;                                               
    if (tmp > p->end) {                                               
      p->end = tmp;                                                   
40004208:	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                 
4000420c:	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;                                                 
40004210:	84 10 20 00 	clr  %g2                                       
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
40004214:	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);
40004218:	ba 06 61 d6 	add  %i1, 0x1d6, %i5                           
    value = (value << 8) + data [i];                                  
4000421c:	c6 0f 40 01 	ldub  [ %i5 + %g1 ], %g3                       
40004220:	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) {                                          
40004224:	82 00 7f ff 	add  %g1, -1, %g1                              
40004228:	80 a0 7f ff 	cmp  %g1, -1                                   
4000422c:	12 bf ff fc 	bne  4000421c <rtems_bdpart_read+0x204>        
40004230:	84 00 c0 02 	add  %g3, %g2, %g2                             
  uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];                 
                                                                      
  if (type == RTEMS_BDPART_MBR_EXTENDED) {                            
40004234:	c2 0e 61 d2 	ldub  [ %i1 + 0x1d2 ], %g1                     
40004238:	80 a0 60 05 	cmp  %g1, 5                                    
4000423c:	02 80 00 11 	be  40004280 <rtems_bdpart_read+0x268>         
40004240:	80 a0 a0 00 	cmp  %g2, 0                                    
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
40004244:	82 21 00 1a 	sub  %g4, %i2, %g1                             
40004248:	83 38 60 04 	sra  %g1, 4, %g1                               
4000424c:	85 28 60 02 	sll  %g1, 2, %g2                               
40004250:	82 00 80 01 	add  %g2, %g1, %g1                             
40004254:	85 28 60 04 	sll  %g1, 4, %g2                               
40004258:	82 00 40 02 	add  %g1, %g2, %g1                             
4000425c:	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;                           
40004260:	b0 10 20 00 	clr  %i0                                       
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  /* Return partition count */                                        
  *count = (size_t) (p - pt + 1);                                     
40004264:	82 00 40 02 	add  %g1, %g2, %g1                             
40004268:	85 28 60 10 	sll  %g1, 0x10, %g2                            
4000426c:	82 00 40 02 	add  %g1, %g2, %g1                             
40004270:	82 20 00 01 	neg  %g1                                       
40004274:	82 00 60 01 	inc  %g1                                       
40004278:	10 bf ff 89 	b  4000409c <rtems_bdpart_read+0x84>           
4000427c:	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) {                                                   
40004280:	02 bf ff f2 	be  40004248 <rtems_bdpart_read+0x230>         <== NEVER TAKEN
40004284:	82 21 00 1a 	sub  %g4, %i2, %g1                             
      /* Adjust partition EBR block index */                          
      tmp = ebr + ep_begin;                                           
40004288:	fa 07 bf f0 	ld  [ %fp + -16 ], %i5                         
4000428c:	ba 00 80 1d 	add  %g2, %i5, %i5                             
      if (tmp > ebr) {                                                
40004290:	80 a7 40 02 	cmp  %i5, %g2                                  
40004294:	18 bf ff c3 	bgu  400041a0 <rtems_bdpart_read+0x188>        <== ALWAYS TAKEN
40004298:	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;                                           
4000429c:	10 bf ff 80 	b  4000409c <rtems_bdpart_read+0x84>           <== NOT EXECUTED
400042a0:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
      esc = sc;                                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Read first partition entry */                                  
    sc = rtems_bdpart_read_mbr_partition(                             
400042a4:	10 bf ff 7e 	b  4000409c <rtems_bdpart_read+0x84>           <== NOT EXECUTED
400042a8:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
                                                                      

40003e48 <rtems_bdpart_read_mbr_partition>: const uint8_t *data, rtems_bdpart_partition **p, const rtems_bdpart_partition *p_end, rtems_blkdev_bnum *ep_begin ) {
40003e48:	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;                                                 
40003e4c:	ba 10 20 00 	clr  %i5                                       
  } else {                                                            
    return 0;                                                         
  }                                                                   
}                                                                     
                                                                      
static rtems_status_code rtems_bdpart_read_mbr_partition(             
40003e50:	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                                         
)                                                                     
{                                                                     
40003e54:	b8 10 00 18 	mov  %i0, %i4                                  
  } else {                                                            
    return 0;                                                         
  }                                                                   
}                                                                     
                                                                      
static rtems_status_code rtems_bdpart_read_mbr_partition(             
40003e58:	82 10 00 04 	mov  %g4, %g1                                  
40003e5c:	86 06 20 07 	add  %i0, 7, %g3                               
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
    value = (value << 8) + data [i];                                  
40003e60:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
40003e64:	bb 2f 60 08 	sll  %i5, 8, %i5                               
40003e68:	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) {                                          
40003e6c:	80 a0 40 03 	cmp  %g1, %g3                                  
40003e70:	12 bf ff fc 	bne  40003e60 <rtems_bdpart_read_mbr_partition+0x18>
40003e74:	ba 00 80 1d 	add  %g2, %i5, %i5                             
40003e78:	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;                                                 
40003e7c:	84 10 20 00 	clr  %g2                                       
  ssize_t i = 0;                                                      
                                                                      
  for (i = 3; i >= 0; --i) {                                          
    value = (value << 8) + data [i];                                  
40003e80:	c6 08 40 00 	ldub  [ %g1 ], %g3                             
40003e84:	85 28 a0 08 	sll  %g2, 8, %g2                               
40003e88:	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) {                                          
40003e8c:	80 a0 40 04 	cmp  %g1, %g4                                  
40003e90:	12 bf ff fc 	bne  40003e80 <rtems_bdpart_read_mbr_partition+0x38>
40003e94:	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) {                               
40003e98:	e0 0f 20 04 	ldub  [ %i4 + 4 ], %l0                         
40003e9c:	80 a4 20 00 	cmp  %l0, 0                                    
40003ea0:	02 80 00 0a 	be  40003ec8 <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
40003ea4:	b0 10 20 00 	clr  %i0                                       
    return RTEMS_SUCCESSFUL;                                          
  } else if (*p == p_end) {                                           
40003ea8:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40003eac:	80 a0 40 1a 	cmp  %g1, %i2                                  
40003eb0:	02 80 00 06 	be  40003ec8 <rtems_bdpart_read_mbr_partition+0x80><== NEVER TAKEN
40003eb4:	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;                               
40003eb8:	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) {                                          
40003ebc:	80 a6 80 1d 	cmp  %i2, %i5                                  
40003ec0:	18 80 00 04 	bgu  40003ed0 <rtems_bdpart_read_mbr_partition+0x88><== ALWAYS TAKEN
40003ec4:	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;                                            
}                                                                     
40003ec8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003ecc:	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) {                     
40003ed0:	80 a4 20 05 	cmp  %l0, 5                                    
40003ed4:	12 80 00 08 	bne  40003ef4 <rtems_bdpart_read_mbr_partition+0xac>
40003ed8:	90 00 60 30 	add  %g1, 0x30, %o0                            
    if (ep_begin != NULL) {                                           
40003edc:	80 a6 e0 00 	cmp  %i3, 0                                    
40003ee0:	02 80 00 15 	be  40003f34 <rtems_bdpart_read_mbr_partition+0xec><== NEVER TAKEN
40003ee4:	01 00 00 00 	nop                                            
      *ep_begin = begin;                                              
40003ee8:	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;                                            
40003eec:	81 c7 e0 08 	ret                                            
40003ef0:	91 e8 20 00 	restore  %g0, 0, %o0                           
  } else {                                                            
    /* Increment partition index */                                   
    ++(*p);                                                           
                                                                      
    /* Clear partition */                                             
    memset( *p, 0, sizeof( rtems_bdpart_partition));                  
40003ef4:	94 10 20 30 	mov  0x30, %o2                                 
40003ef8:	92 10 20 00 	clr  %o1                                       
40003efc:	40 00 4c 52 	call  40017044 <memset>                        
40003f00:	d0 26 40 00 	st  %o0, [ %i1 ]                               
                                                                      
    /* Set values */                                                  
    (*p)->begin = begin;                                              
40003f04:	d2 06 40 00 	ld  [ %i1 ], %o1                               
    (*p)->end = end;                                                  
    rtems_bdpart_to_partition_type( type, (*p)->type);                
40003f08:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
    /* Clear partition */                                             
    memset( *p, 0, sizeof( rtems_bdpart_partition));                  
                                                                      
    /* Set values */                                                  
    (*p)->begin = begin;                                              
40003f0c:	fa 22 40 00 	st  %i5, [ %o1 ]                               
    (*p)->end = end;                                                  
40003f10:	f4 22 60 04 	st  %i2, [ %o1 + 4 ]                           
    rtems_bdpart_to_partition_type( type, (*p)->type);                
40003f14:	7f ff ff c4 	call  40003e24 <rtems_bdpart_to_partition_type>
40003f18:	92 02 60 08 	add  %o1, 8, %o1                               
    (*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];               
40003f1c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40003f20:	c4 0f 00 00 	ldub  [ %i4 ], %g2                             
40003f24:	c0 20 60 28 	clr  [ %g1 + 0x28 ]                            
40003f28:	c4 20 60 2c 	st  %g2, [ %g1 + 0x2c ]                        
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40003f2c:	81 c7 e0 08 	ret                                            
40003f30:	91 e8 20 00 	restore  %g0, 0, %o0                           
}                                                                     
40003f34:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003f38:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      

40003d98 <rtems_bdpart_read_record>: static rtems_status_code rtems_bdpart_read_record( rtems_disk_device *dd, rtems_blkdev_bnum index, rtems_bdbuf_buffer **block ) {
40003d98:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  /* Release previous block if necessary */                           
  if (*block != NULL) {                                               
40003d9c:	d0 06 80 00 	ld  [ %i2 ], %o0                               
40003da0:	80 a2 20 00 	cmp  %o0, 0                                    
40003da4:	22 80 00 08 	be,a   40003dc4 <rtems_bdpart_read_record+0x2c>
40003da8:	90 10 00 18 	mov  %i0, %o0                                  
    sc = rtems_bdbuf_release( *block);                                
40003dac:	40 00 35 91 	call  400113f0 <rtems_bdbuf_release>           
40003db0:	01 00 00 00 	nop                                            
    if (sc != RTEMS_SUCCESSFUL) {                                     
40003db4:	80 a2 20 00 	cmp  %o0, 0                                    
40003db8:	12 80 00 13 	bne  40003e04 <rtems_bdpart_read_record+0x6c>  <== NEVER TAKEN
40003dbc:	01 00 00 00 	nop                                            
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  /* Read the record block */                                         
  sc = rtems_bdbuf_read( dd, index, block);                           
40003dc0:	90 10 00 18 	mov  %i0, %o0                                  
40003dc4:	92 10 00 19 	mov  %i1, %o1                                  
40003dc8:	40 00 35 05 	call  400111dc <rtems_bdbuf_read>              
40003dcc:	94 10 00 1a 	mov  %i2, %o2                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
40003dd0:	80 a2 20 00 	cmp  %o0, 0                                    
40003dd4:	12 80 00 0c 	bne  40003e04 <rtems_bdpart_read_record+0x6c>  <== NEVER TAKEN
40003dd8:	01 00 00 00 	nop                                            
    return sc;                                                        
  }                                                                   
                                                                      
  /* just in case block did not get filled in */                      
  if ( *block == NULL ) {                                             
40003ddc:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40003de0:	80 a0 60 00 	cmp  %g1, 0                                    
40003de4:	22 80 00 0e 	be,a   40003e1c <rtems_bdpart_read_record+0x84><== NEVER TAKEN
40003de8:	90 10 20 09 	mov  9, %o0                                    <== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  /* Check MBR signature */                                           
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
40003dec:	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]                     
40003df0:	c4 08 61 fe 	ldub  [ %g1 + 0x1fe ], %g2                     
40003df4:	80 a0 a0 55 	cmp  %g2, 0x55                                 
40003df8:	22 80 00 05 	be,a   40003e0c <rtems_bdpart_read_record+0x74><== ALWAYS TAKEN
40003dfc:	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;                                            
40003e00:	90 10 20 1b 	mov  0x1b, %o0                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003e04:	81 c7 e0 08 	ret                                            
40003e08:	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]                     
40003e0c:	80 a0 60 aa 	cmp  %g1, 0xaa                                 
40003e10:	32 bf ff fd 	bne,a   40003e04 <rtems_bdpart_read_record+0x6c><== NEVER TAKEN
40003e14:	90 10 20 1b 	mov  0x1b, %o0                                 <== NOT EXECUTED
40003e18:	30 bf ff fb 	b,a   40003e04 <rtems_bdpart_read_record+0x6c> 
  if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {             
    return RTEMS_IO_ERROR;                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40003e1c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40003e20:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

400042ac <rtems_bdpart_register>: rtems_status_code rtems_bdpart_register( const char *disk_name, const rtems_bdpart_partition *pt, size_t count ) {
400042ac:	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);                         
400042b0:	90 10 00 18 	mov  %i0, %o0                                  
400042b4:	40 00 4d 16 	call  4001770c <strlen>                        
400042b8:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  size_t i = 0;                                                       
  int fd = -1;                                                        
400042bc:	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                                                        
)                                                                     
{                                                                     
400042c0:	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);                         
400042c4:	a4 10 00 08 	mov  %o0, %l2                                  
  size_t i = 0;                                                       
  int fd = -1;                                                        
400042c8:	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);   
400042cc:	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;                                       
400042d0:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
400042d4:	92 07 bf f8 	add  %fp, -8, %o1                              
400042d8:	94 07 bf fc 	add  %fp, -4, %o2                              
400042dc:	7f ff ff 24 	call  40003f6c <rtems_bdpart_get_disk_data>    
400042e0:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
400042e4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400042e8:	12 80 00 32 	bne  400043b0 <rtems_bdpart_register+0x104>    <== NEVER TAKEN
400042ec:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    return sc;                                                        
  }                                                                   
  disk = rtems_disk_get_device_identifier( dd);                       
  close( fd);                                                         
400042f0:	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;                                                     
400042f4:	e2 00 60 04 	ld  [ %g1 + 4 ], %l1                           
400042f8:	40 00 08 76 	call  400064d0 <close>                         
400042fc:	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);
40004300:	90 04 a0 04 	add  %l2, 4, %o0                               
40004304:	40 00 0a 32 	call  40006bcc <malloc>                        
40004308:	b8 10 00 11 	mov  %l1, %i4                                  
  if (logical_disk_name == NULL) {                                    
    return RTEMS_NO_MEMORY;                                           
4000430c:	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) {                                    
40004310:	80 a2 20 00 	cmp  %o0, 0                                    
40004314:	02 80 00 27 	be  400043b0 <rtems_bdpart_register+0x104>     <== NEVER TAKEN
40004318:	a0 10 00 08 	mov  %o0, %l0                                  
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
  strncpy( logical_disk_name, disk_name, disk_name_size);             
4000431c:	92 10 00 1d 	mov  %i5, %o1                                  
40004320:	40 00 4d 83 	call  4001792c <strncpy>                       
40004324:	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);
40004328:	31 10 00 99 	sethi  %hi(0x40026400), %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;           
4000432c:	a4 04 00 12 	add  %l0, %l2, %l2                             
                                                                      
  /* Create a logical disk for each partition */                      
  for (i = 0; i < count; ++i) {                                       
40004330:	ba 10 20 00 	clr  %i5                                       
40004334:	80 a6 a0 00 	cmp  %i2, 0                                    
40004338:	12 80 00 06 	bne  40004350 <rtems_bdpart_register+0xa4>     <== ALWAYS TAKEN
4000433c:	b0 16 22 98 	or  %i0, 0x298, %i0                            
  const rtems_bdpart_partition *pt,                                   
  size_t count                                                        
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
40004340:	10 80 00 1a 	b  400043a8 <rtems_bdpart_register+0xfc>       <== NOT EXECUTED
40004344:	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) {                                       
40004348:	02 80 00 1c 	be  400043b8 <rtems_bdpart_register+0x10c>     
4000434c:	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);
40004350:	92 10 20 04 	mov  4, %o1                                    
40004354:	94 10 00 18 	mov  %i0, %o2                                  
40004358:	ba 07 60 01 	inc  %i5                                       
4000435c:	90 10 00 12 	mov  %l2, %o0                                  
40004360:	40 00 4b fc 	call  40017350 <snprintf>                      
40004364:	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;                                                          
40004368:	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) {                             
4000436c:	80 a2 20 03 	cmp  %o0, 3                                    
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
40004370:	92 10 00 1c 	mov  %i4, %o1                                  
40004374:	94 10 00 1b 	mov  %i3, %o2                                  
40004378:	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) {                             
4000437c:	14 80 00 11 	bg  400043c0 <rtems_bdpart_register+0x114>     <== NEVER TAKEN
40004380:	90 10 00 1b 	mov  %i3, %o0                                  
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
40004384:	da 06 60 04 	ld  [ %i1 + 4 ], %o5                           
      logical_disk,                                                   
      disk,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
40004388:	d8 06 40 00 	ld  [ %i1 ], %o4                               
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
4000438c:	e0 23 a0 5c 	st  %l0, [ %sp + 0x5c ]                        
40004390:	40 00 03 7d 	call  40005184 <rtems_disk_create_log>         
40004394:	9a 23 40 0c 	sub  %o5, %o4, %o5                             
      disk,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
      logical_disk_name                                               
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
40004398:	80 a2 20 00 	cmp  %o0, 0                                    
4000439c:	02 bf ff eb 	be  40004348 <rtems_bdpart_register+0x9c>      <== ALWAYS TAKEN
400043a0:	80 a7 40 1a 	cmp  %i5, %i2                                  
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Create logical disk */                                         
    sc = rtems_disk_create_log(                                       
400043a4:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( logical_disk_name);                                           
400043a8:	40 00 08 6c 	call  40006558 <free>                          
400043ac:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
  return esc;                                                         
}                                                                     
400043b0:	81 c7 e0 08 	ret                                            
400043b4:	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;                           
400043b8:	10 bf ff fc 	b  400043a8 <rtems_bdpart_register+0xfc>       
400043bc:	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;                                       
400043c0:	10 bf ff fa 	b  400043a8 <rtems_bdpart_register+0xfc>       <== NOT EXECUTED
400043c4:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
                                                                      

400043c8 <rtems_bdpart_register_from_disk>: return esc; } rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name) {
400043c8:	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;                  
400043cc:	82 10 20 10 	mov  0x10, %g1                                 
                                                                      
  /* Read partitions */                                               
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);            
400043d0:	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;                  
400043d4:	c2 27 bc e8 	st  %g1, [ %fp + -792 ]                        
                                                                      
  /* Read partitions */                                               
  sc = rtems_bdpart_read( disk_name, &format, pt, &count);            
400043d8:	92 07 bc ec 	add  %fp, -788, %o1                            
400043dc:	94 07 bd 00 	add  %fp, -768, %o2                            
400043e0:	7f ff ff 0e 	call  40004018 <rtems_bdpart_read>             
400043e4:	96 07 bc e8 	add  %fp, -792, %o3                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
400043e8:	80 a2 20 00 	cmp  %o0, 0                                    
400043ec:	12 80 00 05 	bne  40004400 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
400043f0:	d4 07 bc e8 	ld  [ %fp + -792 ], %o2                        
    return sc;                                                        
  }                                                                   
                                                                      
  /* Register partitions */                                           
  return rtems_bdpart_register( disk_name, pt, count);                
400043f4:	90 10 00 18 	mov  %i0, %o0                                  
400043f8:	7f ff ff ad 	call  400042ac <rtems_bdpart_register>         
400043fc:	92 07 bd 00 	add  %fp, -768, %o1                            
}                                                                     
40004400:	81 c7 e0 08 	ret                                            
40004404:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

400252b4 <rtems_bdpart_unmount>: const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count, const char *mount_base ) {
400252b4:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
  const char *disk_file_name = strrchr( disk_name, '/');              
400252b8:	92 10 20 2f 	mov  0x2f, %o1                                 <== NOT EXECUTED
400252bc:	40 00 7d 1c 	call  4004472c <strrchr>                       <== NOT EXECUTED
400252c0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400252c4:	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);                         
400252c8:	40 00 78 f6 	call  400436a0 <strlen>                        <== NOT EXECUTED
400252cc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400252d0:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
  size_t mount_base_size = strlen( mount_base);                       
400252d4:	40 00 78 f3 	call  400436a0 <strlen>                        <== NOT EXECUTED
400252d8:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  size_t i = 0;                                                       
                                                                      
  /* Get disk file name */                                            
  if (disk_file_name != NULL) {                                       
400252dc:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
400252e0:	02 80 00 42 	be  400253e8 <rtems_bdpart_unmount+0x134>      <== NOT EXECUTED
400252e4:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    disk_file_name += 1;                                              
400252e8:	a2 07 20 01 	add  %i4, 1, %l1                               <== NOT EXECUTED
    disk_file_name_size = strlen( disk_file_name);                    
400252ec:	40 00 78 ed 	call  400436a0 <strlen>                        <== NOT EXECUTED
400252f0:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
400252f4:	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);
400252f8:	b2 04 00 1d 	add  %l0, %i5, %i1                             <== NOT EXECUTED
  if (mount_point == NULL) {                                          
    esc = RTEMS_NO_MEMORY;                                            
400252fc:	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);
40025300:	7f ff 7b 76 	call  400040d8 <malloc>                        <== NOT EXECUTED
40025304:	90 06 60 05 	add  %i1, 5, %o0                               <== NOT EXECUTED
  if (mount_point == NULL) {                                          
40025308:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4002530c:	02 80 00 2b 	be  400253b8 <rtems_bdpart_unmount+0x104>      <== NOT EXECUTED
40025310:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
    esc = RTEMS_NO_MEMORY;                                            
    goto cleanup;                                                     
  }                                                                   
  strncpy( mount_point, mount_base, mount_base_size);                 
40025314:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40025318:	40 00 79 9e 	call  40043990 <strncpy>                       <== NOT EXECUTED
4002531c:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
  mount_point [mount_base_size] = '/';                                
40025320:	82 10 20 2f 	mov  0x2f, %g1                                 <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
40025324:	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] = '/';                                
40025328:	c2 2f 00 1d 	stb  %g1, [ %i4 + %i5 ]                        <== NOT EXECUTED
  strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
4002532c:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
40025330:	90 07 00 08 	add  %i4, %o0, %o0                             <== NOT EXECUTED
40025334:	40 00 79 97 	call  40043990 <strncpy>                       <== NOT EXECUTED
40025338:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
                                                                      
  /* Marker */                                                        
  mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
4002533c:	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);
40025340:	37 10 01 86 	sethi  %hi(0x40061800), %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) {                                       
40025344:	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;
40025348:	b2 07 00 19 	add  %i4, %i1, %i1                             <== NOT EXECUTED
                                                                      
  /* Mount supported file systems for each partition */               
  for (i = 0; i < count; ++i) {                                       
4002534c:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
40025350:	12 80 00 06 	bne  40025368 <rtems_bdpart_unmount+0xb4>      <== NOT EXECUTED
40025354:	b6 16 e1 08 	or  %i3, 0x108, %i3                            <== NOT EXECUTED
  const rtems_bdpart_partition *pt __attribute__((unused)),           
  size_t count,                                                       
  const char *mount_base                                              
)                                                                     
{                                                                     
  rtems_status_code esc = RTEMS_SUCCESSFUL;                           
40025358:	10 80 00 1c 	b  400253c8 <rtems_bdpart_unmount+0x114>       <== NOT EXECUTED
4002535c:	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) {                                       
40025360:	02 80 00 1a 	be  400253c8 <rtems_bdpart_unmount+0x114>      <== NOT EXECUTED
40025364:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    /* Create mount point */                                          
    int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
40025368:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
4002536c:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
40025370:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40025374:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40025378:	40 00 75 52 	call  400428c0 <snprintf>                      <== NOT EXECUTED
4002537c:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
    if (rv >= RTEMS_BDPART_NUMBER_SIZE) {                             
40025380:	80 a2 20 03 	cmp  %o0, 3                                    <== NOT EXECUTED
40025384:	14 80 00 15 	bg  400253d8 <rtems_bdpart_unmount+0x124>      <== NOT EXECUTED
40025388:	b0 10 20 03 	mov  3, %i0                                    <== NOT EXECUTED
      esc = RTEMS_INVALID_NAME;                                       
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Unmount */                                                     
    rv = unmount( mount_point);                                       
4002538c:	40 00 11 15 	call  400297e0 <unmount>                       <== NOT EXECUTED
40025390:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    if (rv == 0) {                                                    
40025394:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40025398:	12 bf ff f2 	bne  40025360 <rtems_bdpart_unmount+0xac>      <== NOT EXECUTED
4002539c:	80 a7 40 1a 	cmp  %i5, %i2                                  <== NOT EXECUTED
      /* Remove mount point */                                        
      rv = rmdir( mount_point);                                       
400253a0:	40 00 0f 5b 	call  4002910c <rmdir>                         <== NOT EXECUTED
400253a4:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
      if (rv != 0) {                                                  
400253a8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400253ac:	02 bf ff ed 	be  40025360 <rtems_bdpart_unmount+0xac>       <== NOT EXECUTED
400253b0:	80 a7 40 1a 	cmp  %i5, %i2                                  <== NOT EXECUTED
        esc = RTEMS_IO_ERROR;                                         
400253b4:	b0 10 20 1b 	mov  0x1b, %i0                                 <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( mount_point);                                                 
400253b8:	7f ff 7a 6e 	call  40003d70 <free>                          <== NOT EXECUTED
400253bc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
400253c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400253c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( mount_point);                                                 
400253c8:	7f ff 7a 6a 	call  40003d70 <free>                          <== NOT EXECUTED
400253cc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
400253d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400253d4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  free( mount_point);                                                 
400253d8:	7f ff 7a 66 	call  40003d70 <free>                          <== NOT EXECUTED
400253dc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
  return esc;                                                         
}                                                                     
400253e0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400253e4:	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;                                       
400253e8:	10 bf ff c4 	b  400252f8 <rtems_bdpart_unmount+0x44>        <== NOT EXECUTED
400253ec:	a2 10 00 18 	mov  %i0, %l1                                  <== NOT EXECUTED
                                                                      

40004408 <rtems_bdpart_unregister>: rtems_status_code rtems_bdpart_unregister( const char *disk_name, const rtems_bdpart_partition *pt __attribute__((unused)), size_t count ) {
40004408:	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;                                                        
4000440c:	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);   
40004410:	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;                                     
40004414:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
  dev_t disk = 0;                                                     
  dev_t logical_disk = 0;                                             
  size_t i = 0;                                                       
  int fd = -1;                                                        
40004418:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
4000441c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  /* Get disk data */                                                 
  sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);   
40004420:	92 07 bf f8 	add  %fp, -8, %o1                              
40004424:	94 07 bf fc 	add  %fp, -4, %o2                              
40004428:	7f ff fe d1 	call  40003f6c <rtems_bdpart_get_disk_data>    
4000442c:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004430:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40004434:	12 80 00 14 	bne  40004484 <rtems_bdpart_unregister+0x7c>   <== NEVER TAKEN
40004438:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    return sc;                                                        
  }                                                                   
  disk = rtems_disk_get_device_identifier( dd);                       
  close( fd);                                                         
4000443c:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
40004440:	40 00 08 24 	call  400064d0 <close>                         
40004444:	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) {                                       
40004448:	80 a6 a0 00 	cmp  %i2, 0                                    
4000444c:	12 80 00 05 	bne  40004460 <rtems_bdpart_unregister+0x58>   <== ALWAYS TAKEN
40004450:	b4 06 80 1d 	add  %i2, %i5, %i2                             
40004454:	30 80 00 0c 	b,a   40004484 <rtems_bdpart_unregister+0x7c>  <== NOT EXECUTED
40004458:	02 80 00 0b 	be  40004484 <rtems_bdpart_unregister+0x7c>    
4000445c:	01 00 00 00 	nop                                            
    /* New minor number */                                            
    ++minor;                                                          
40004460:	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);                            
40004464:	90 10 00 1c 	mov  %i4, %o0                                  
40004468:	40 00 02 cc 	call  40004f98 <rtems_disk_delete>             
4000446c:	92 10 00 1d 	mov  %i5, %o1                                  
    if (sc != RTEMS_SUCCESSFUL) {                                     
40004470:	80 a2 20 00 	cmp  %o0, 0                                    
40004474:	02 bf ff f9 	be  40004458 <rtems_bdpart_unregister+0x50>    <== ALWAYS TAKEN
40004478:	80 a7 40 1a 	cmp  %i5, %i2                                  
      return sc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000447c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004480:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
40004484:	81 c7 e0 08 	ret                                            
40004488:	81 e8 00 00 	restore                                        
                                                                      

4000451c <rtems_bdpart_write>: const char *disk_name, const rtems_bdpart_format *format, const rtems_bdpart_partition *pt, size_t count ) {
4000451c:	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;                                 
40004520:	80 a6 60 00 	cmp  %i1, 0                                    
40004524:	02 80 00 06 	be  4000453c <rtems_bdpart_write+0x20>         <== NEVER TAKEN
40004528:	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                        
4000452c:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40004530:	80 a0 60 00 	cmp  %g1, 0                                    
40004534:	22 80 00 11 	be,a   40004578 <rtems_bdpart_write+0x5c>      <== ALWAYS TAKEN
40004538:	c2 0e 60 08 	ldub  [ %i1 + 8 ], %g1                         
    && format->mbr.dos_compatibility;                                 
  rtems_bdbuf_buffer *block = NULL;                                   
4000453c:	c0 27 bf f0 	clr  [ %fp + -16 ]                             <== NOT EXECUTED
  rtems_blkdev_bnum disk_end = 0;                                     
40004540:	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                             
40004544:	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 =                                    
40004548:	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;                                                        
4000454c:	82 10 3f ff 	mov  -1, %g1                                   
  rtems_disk_device *dd = NULL;                                       
40004550:	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;                                                        
40004554:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
  rtems_disk_device *dd = NULL;                                       
                                                                      
  /* Check if we have something to do */                              
  if (count == 0) {                                                   
40004558:	80 a6 e0 00 	cmp  %i3, 0                                    
4000455c:	02 80 00 4e 	be  40004694 <rtems_bdpart_write+0x178>        <== NEVER TAKEN
40004560:	b0 10 20 00 	clr  %i0                                       
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL) {                                 
40004564:	80 a6 a0 00 	cmp  %i2, 0                                    
40004568:	12 80 00 0b 	bne  40004594 <rtems_bdpart_write+0x78>        <== ALWAYS TAKEN
4000456c:	80 a6 60 00 	cmp  %i1, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
40004570:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004574:	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;                                 
40004578:	80 a0 60 00 	cmp  %g1, 0                                    
4000457c:	02 bf ff f1 	be  40004540 <rtems_bdpart_write+0x24>         <== NEVER TAKEN
40004580:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
  rtems_bdbuf_buffer *block = NULL;                                   
  rtems_blkdev_bnum disk_end = 0;                                     
40004584:	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                             
40004588:	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 =                                    
4000458c:	10 bf ff f0 	b  4000454c <rtems_bdpart_write+0x30>          
40004590:	b8 10 20 3f 	mov  0x3f, %i4                                 
    /* Nothing to do */                                               
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  /* Check parameter */                                               
  if (format == NULL || pt == NULL) {                                 
40004594:	02 bf ff f7 	be  40004570 <rtems_bdpart_write+0x54>         <== NEVER TAKEN
40004598:	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);   
4000459c:	94 07 bf fc 	add  %fp, -4, %o2                              
400045a0:	7f ff fe 73 	call  40003f6c <rtems_bdpart_get_disk_data>    
400045a4:	96 07 bf f4 	add  %fp, -12, %o3                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
400045a8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400045ac:	12 80 00 3a 	bne  40004694 <rtems_bdpart_write+0x178>       <== NEVER TAKEN
400045b0:	ba 8f 60 ff 	andcc  %i5, 0xff, %i5                          
    return sc;                                                        
  }                                                                   
                                                                      
  /* Align end of disk on cylinder boundary if necessary */           
  if (dos_compatibility) {                                            
400045b4:	32 80 00 25 	bne,a   40004648 <rtems_bdpart_write+0x12c>    <== ALWAYS TAKEN
400045b8:	f0 07 bf f4 	ld  [ %fp + -12 ], %i0                         
400045bc:	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) {                  
400045c0:	de 06 80 00 	ld  [ %i2 ], %o7                               
400045c4:	80 a3 c0 08 	cmp  %o7, %o0                                  
400045c8:	3a 80 00 27 	bcc,a   40004664 <rtems_bdpart_write+0x148>    <== NEVER TAKEN
400045cc:	b0 10 20 0a 	mov  0xa, %i0                                  <== NOT EXECUTED
400045d0:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
400045d4:	80 a2 00 01 	cmp  %o0, %g1                                  
400045d8:	0a 80 00 22 	bcs  40004660 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
400045dc:	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) {                                         
400045e0:	1a 80 00 20 	bcc  40004660 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
400045e4:	a2 10 00 1a 	mov  %i2, %l1                                  
400045e8:	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) {                                       
400045ec:	84 10 20 00 	clr  %g2                                       
400045f0:	84 00 a0 01 	inc  %g2                                       
400045f4:	80 a0 80 1b 	cmp  %g2, %i3                                  
400045f8:	22 80 00 29 	be,a   4000469c <rtems_bdpart_write+0x180>     
400045fc:	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) {                  
40004600:	c6 00 60 30 	ld  [ %g1 + 0x30 ], %g3                        
40004604:	80 a0 c0 08 	cmp  %g3, %o0                                  
40004608:	3a 80 00 17 	bcc,a   40004664 <rtems_bdpart_write+0x148>    <== NEVER TAKEN
4000460c:	b0 10 20 0a 	mov  0xa, %i0                                  <== NOT EXECUTED
40004610:	c8 00 60 34 	ld  [ %g1 + 0x34 ], %g4                        
40004614:	80 a1 00 08 	cmp  %g4, %o0                                  
40004618:	18 80 00 12 	bgu  40004660 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
4000461c:	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) {                                         
40004620:	1a 80 00 10 	bcc  40004660 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
40004624:	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) {                         
40004628:	22 bf ff f2 	be,a   400045f0 <rtems_bdpart_write+0xd4>      <== NEVER TAKEN
4000462c:	82 00 60 30 	add  %g1, 0x30, %g1                            <== NOT EXECUTED
40004630:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
40004634:	80 a0 c0 04 	cmp  %g3, %g4                                  
40004638:	0a 80 00 0a 	bcs  40004660 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
4000463c:	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) {                                       
40004640:	10 bf ff ed 	b  400045f4 <rtems_bdpart_write+0xd8>          
40004644:	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);                            
40004648:	92 10 00 1c 	mov  %i4, %o1                                  
4000464c:	40 00 7a ad 	call  40023100 <.urem>                         
40004650:	90 10 00 18 	mov  %i0, %o0                                  
40004654:	90 26 00 08 	sub  %i0, %o0, %o0                             
40004658:	10 bf ff da 	b  400045c0 <rtems_bdpart_write+0xa4>          
4000465c:	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;                                     
40004660:	b0 10 20 0a 	mov  0xa, %i0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
cleanup:                                                              
                                                                      
  if (fd >= 0) {                                                      
40004664:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
40004668:	80 a2 20 00 	cmp  %o0, 0                                    
4000466c:	26 80 00 05 	bl,a   40004680 <rtems_bdpart_write+0x164>     <== NEVER TAKEN
40004670:	d0 07 bf f0 	ld  [ %fp + -16 ], %o0                         <== NOT EXECUTED
    close( fd);                                                       
40004674:	40 00 07 97 	call  400064d0 <close>                         
40004678:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  if (block != NULL) {                                                
4000467c:	d0 07 bf f0 	ld  [ %fp + -16 ], %o0                         
40004680:	80 a2 20 00 	cmp  %o0, 0                                    
40004684:	02 80 00 04 	be  40004694 <rtems_bdpart_write+0x178>        <== NEVER TAKEN
40004688:	01 00 00 00 	nop                                            
    rtems_bdbuf_sync( block);                                         
4000468c:	40 00 33 b1 	call  40011550 <rtems_bdbuf_sync>              
40004690:	01 00 00 00 	nop                                            
40004694:	81 c7 e0 08 	ret                                            
40004698:	81 e8 00 00 	restore                                        
      goto cleanup;                                                   
    }                                                                 
  }                                                                   
                                                                      
  /* Check format */                                                  
  if (format->type != RTEMS_BDPART_FORMAT_MBR) {                      
4000469c:	80 a0 60 00 	cmp  %g1, 0                                    
400046a0:	12 bf ff f1 	bne  40004664 <rtems_bdpart_write+0x148>       <== NEVER TAKEN
400046a4:	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;                                       
400046a8:	80 a6 e0 04 	cmp  %i3, 4                                    
400046ac:	08 80 00 03 	bleu  400046b8 <rtems_bdpart_write+0x19c>      <== NEVER TAKEN
400046b0:	a0 10 00 1b 	mov  %i3, %l0                                  
400046b4:	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) {
400046b8:	80 a7 60 00 	cmp  %i5, 0                                    
400046bc:	02 80 00 06 	be  400046d4 <rtems_bdpart_write+0x1b8>        <== NEVER TAKEN
400046c0:	80 a4 00 1b 	cmp  %l0, %i3                                  
400046c4:	80 a3 e0 3f 	cmp  %o7, 0x3f                                 
400046c8:	12 bf ff e7 	bne  40004664 <rtems_bdpart_write+0x148>       <== NEVER TAKEN
400046cc:	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) {                                     
400046d0:	80 a4 00 1b 	cmp  %l0, %i3                                  
400046d4:	1a 80 00 1c 	bcc  40004744 <rtems_bdpart_write+0x228>       <== NEVER TAKEN
400046d8:	84 04 3f ff 	add  %l0, -1, %g2                              
    if ((pt [i].begin - pt [i - 1].end) < record_space) {             
400046dc:	89 2c 20 06 	sll  %l0, 6, %g4                               
400046e0:	87 28 a0 04 	sll  %g2, 4, %g3                               
400046e4:	83 2c 20 04 	sll  %l0, 4, %g1                               
400046e8:	85 28 a0 06 	sll  %g2, 6, %g2                               
400046ec:	82 21 00 01 	sub  %g4, %g1, %g1                             
400046f0:	84 20 80 03 	sub  %g2, %g3, %g2                             
400046f4:	c8 06 80 01 	ld  [ %i2 + %g1 ], %g4                         
400046f8:	84 06 80 02 	add  %i2, %g2, %g2                             
400046fc:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
40004700:	84 06 80 01 	add  %i2, %g1, %g2                             
40004704:	82 21 00 03 	sub  %g4, %g3, %g1                             
40004708:	80 a7 00 01 	cmp  %i4, %g1                                  
4000470c:	18 bf ff d5 	bgu  40004660 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
40004710:	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) {                                     
40004714:	10 80 00 09 	b  40004738 <rtems_bdpart_write+0x21c>         
40004718:	82 00 60 01 	inc  %g1                                       
    if ((pt [i].begin - pt [i - 1].end) < record_space) {             
4000471c:	c8 00 e0 30 	ld  [ %g3 + 0x30 ], %g4                        
40004720:	c6 00 e0 04 	ld  [ %g3 + 4 ], %g3                           
40004724:	86 21 00 03 	sub  %g4, %g3, %g3                             
40004728:	80 a7 00 03 	cmp  %i4, %g3                                  
4000472c:	18 bf ff cd 	bgu  40004660 <rtems_bdpart_write+0x144>       <== NEVER TAKEN
40004730:	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) {                                     
40004734:	82 00 60 01 	inc  %g1                                       
40004738:	80 a6 c0 01 	cmp  %i3, %g1                                  
4000473c:	18 bf ff f8 	bgu  4000471c <rtems_bdpart_write+0x200>       
40004740:	86 10 00 02 	mov  %g2, %g3                                  
40004744:	ba 10 00 1a 	mov  %i2, %i5                                  
40004748:	b0 10 20 00 	clr  %i0                                       
4000474c:	10 80 00 0c 	b  4000477c <rtems_bdpart_write+0x260>         
40004750:	a4 07 bf ef 	add  %fp, -17, %l2                             
      esc =  RTEMS_INVALID_ID;                                        
      goto cleanup;                                                   
    }                                                                 
                                                                      
    /* Check flags */                                                 
    if (p->flags > 0xffU) {                                           
40004754:	80 a0 60 00 	cmp  %g1, 0                                    
40004758:	12 80 00 10 	bne  40004798 <rtems_bdpart_write+0x27c>       <== NEVER TAKEN
4000475c:	b0 06 20 01 	inc  %i0                                       
40004760:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
40004764:	80 a0 60 ff 	cmp  %g1, 0xff                                 
40004768:	18 80 00 0c 	bgu  40004798 <rtems_bdpart_write+0x27c>       <== NEVER TAKEN
4000476c:	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) {                                       
40004770:	80 a6 00 1b 	cmp  %i0, %i3                                  
40004774:	02 80 00 0b 	be  400047a0 <rtems_bdpart_write+0x284>        
40004778:	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)) {       
4000477c:	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;                                                 
40004780:	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)) {       
40004784:	7f ff fd ee 	call  40003f3c <rtems_bdpart_to_mbr_partition_type>
40004788:	92 10 00 12 	mov  %l2, %o1                                  
4000478c:	80 8a 20 ff 	btst  0xff, %o0                                
40004790:	32 bf ff f1 	bne,a   40004754 <rtems_bdpart_write+0x238>    <== ALWAYS TAKEN
40004794:	c2 07 60 28 	ld  [ %i5 + 0x28 ], %g1                        
40004798:	10 bf ff b3 	b  40004664 <rtems_bdpart_write+0x148>         <== NOT EXECUTED
4000479c:	b0 10 20 04 	mov  4, %i0                                    <== NOT EXECUTED
    /* Check ID */                                                    
    /* TODO */                                                        
  }                                                                   
                                                                      
  /* New MBR */                                                       
  sc = rtems_bdpart_new_record( dd, 0, &block);                       
400047a0:	92 10 20 00 	clr  %o1                                       
400047a4:	7f ff ff 3a 	call  4000448c <rtems_bdpart_new_record>       
400047a8:	94 07 bf f0 	add  %fp, -16, %o2                             
  if (sc != RTEMS_SUCCESSFUL) {                                       
400047ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400047b0:	12 bf ff ae 	bne  40004668 <rtems_bdpart_write+0x14c>       <== NEVER TAKEN
400047b4:	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                   
400047b8:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Write disk ID */                                                 
  rtems_uint32_to_little_endian(                                      
400047bc:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
    format->mbr.disk_id,                                              
    block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID                   
400047c0:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
    esc = sc;                                                         
    goto cleanup;                                                     
  }                                                                   
                                                                      
  /* Write disk ID */                                                 
  rtems_uint32_to_little_endian(                                      
400047c4:	82 00 e1 b8 	add  %g3, 0x1b8, %g1                           
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
400047c8:	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;                                       
400047cc:	c4 28 40 00 	stb  %g2, [ %g1 ]                              
400047d0:	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) {                                           
400047d4:	80 a0 40 03 	cmp  %g1, %g3                                  
400047d8:	12 bf ff fd 	bne  400047cc <rtems_bdpart_write+0x2b0>       
400047dc:	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;             
400047e0:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
400047e4:	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;             
400047e8:	c8 00 60 1c 	ld  [ %g1 + 0x1c ], %g4                        
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
400047ec:	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;             
400047f0:	9a 01 21 be 	add  %g4, 0x1be, %o5                           
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
400047f4:	98 23 00 0f 	sub  %o4, %o7, %o4                             
400047f8:	88 01 21 ca 	add  %g4, 0x1ca, %g4                           
400047fc:	b0 06 80 0c 	add  %i2, %o4, %i0                             
                                                                      
    /* Write partition entry */                                       
    rtems_bdpart_write_mbr_partition(                                 
      data,                                                           
      p->begin,                                                       
      p->end - p->begin,                                              
40004800:	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(                                 
40004804:	c6 04 60 04 	ld  [ %l1 + 4 ], %g3                           
  if (block != NULL) {                                                
    rtems_bdbuf_sync( block);                                         
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
40004808:	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(                                 
4000480c:	fa 0c 60 2f 	ldub  [ %l1 + 0x2f ], %i5                      
40004810:	86 20 c0 02 	sub  %g3, %g2, %g3                             
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
40004814:	82 01 3f fc 	add  %g4, -4, %g1                              
    data [i] = (uint8_t) value;                                       
40004818:	c4 28 40 00 	stb  %g2, [ %g1 ]                              
4000481c:	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) {                                           
40004820:	80 a1 00 01 	cmp  %g4, %g1                                  
40004824:	12 bf ff fd 	bne  40004818 <rtems_bdpart_write+0x2fc>       
40004828:	85 30 a0 08 	srl  %g2, 8, %g2                               
4000482c:	84 01 20 04 	add  %g4, 4, %g2                               
40004830:	82 10 00 04 	mov  %g4, %g1                                  
    data [i] = (uint8_t) value;                                       
40004834:	c6 28 40 00 	stb  %g3, [ %g1 ]                              
40004838:	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) {                                           
4000483c:	80 a0 40 02 	cmp  %g1, %g2                                  
40004840:	12 bf ff fd 	bne  40004834 <rtems_bdpart_write+0x318>       
40004844:	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;                         
40004848:	f2 29 3f f8 	stb  %i1, [ %g4 + -8 ]                         
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
4000484c:	fa 29 3f f4 	stb  %i5, [ %g4 + -12 ]                        
40004850:	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) {                                         
40004854:	80 a4 40 18 	cmp  %l1, %i0                                  
40004858:	12 bf ff ea 	bne  40004800 <rtems_bdpart_write+0x2e4>       
4000485c:	88 01 20 10 	add  %g4, 0x10, %g4                            
40004860:	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) {                                                 
40004864:	80 a4 00 1b 	cmp  %l0, %i3                                  
40004868:	02 bf ff 7f 	be  40004664 <rtems_bdpart_write+0x148>        <== NEVER TAKEN
4000486c:	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;       
40004870:	fa 06 80 0c 	ld  [ %i2 + %o4 ], %i5                         
                                                                      
    /* Write extended partition */                                    
    rtems_bdpart_write_mbr_partition(                                 
40004874:	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;       
40004878:	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);
4000487c:	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(                                 
40004880:	86 20 c0 1d 	sub  %g3, %i5, %g3                             
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
40004884:	b2 00 a0 0c 	add  %g2, 0xc, %i1                             
40004888:	88 10 00 1d 	mov  %i5, %g4                                  
    data [i] = (uint8_t) value;                                       
4000488c:	c8 28 40 00 	stb  %g4, [ %g1 ]                              
40004890:	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) {                                           
40004894:	80 a0 40 19 	cmp  %g1, %i1                                  
40004898:	12 bf ff fd 	bne  4000488c <rtems_bdpart_write+0x370>       
4000489c:	89 31 20 08 	srl  %g4, 8, %g4                               
400048a0:	88 00 a0 10 	add  %g2, 0x10, %g4                            
    data [i] = (uint8_t) value;                                       
400048a4:	c6 28 40 00 	stb  %g3, [ %g1 ]                              
400048a8:	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) {                                           
400048ac:	80 a0 40 04 	cmp  %g1, %g4                                  
400048b0:	12 bf ff fd 	bne  400048a4 <rtems_bdpart_write+0x388>       
400048b4:	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;                         
400048b8:	82 10 20 05 	mov  5, %g1                                    
400048bc:	c2 28 a0 04 	stb  %g1, [ %g2 + 4 ]                          
      RTEMS_BDPART_MBR_EXTENDED,                                      
      0                                                               
    );                                                                
                                                                      
    /* Write logical partitions */                                    
    for (i = ppc; i < count; ++i) {                                   
400048c0:	80 a4 00 1b 	cmp  %l0, %i3                                  
400048c4:	1a 80 00 44 	bcc  400049d4 <rtems_bdpart_write+0x4b8>       <== NEVER TAKEN
400048c8:	c0 2b 40 0f 	clrb  [ %o5 + %o7 ]                            
400048cc:	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;                         
400048d0:	b2 10 20 05 	mov  5, %i1                                    
    RTEMS_BDPART_MBR_SIGNATURE_1;                                     
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code rtems_bdpart_write(                                 
400048d4:	83 2c a0 04 	sll  %l2, 4, %g1                               
400048d8:	85 2c a0 06 	sll  %l2, 6, %g2                               
400048dc:	82 20 80 01 	sub  %g2, %g1, %g1                             
400048e0:	b4 06 80 01 	add  %i2, %g1, %i2                             
          0                                                           
        );                                                            
      }                                                               
                                                                      
      /* New EBR */                                                   
      ebr = p->begin - record_space;                                  
400048e4:	d2 04 40 00 	ld  [ %l1 ], %o1                               
      sc = rtems_bdpart_new_record( dd, ebr, &block);                 
400048e8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
400048ec:	92 22 40 1c 	sub  %o1, %i4, %o1                             
400048f0:	7f ff fe e7 	call  4000448c <rtems_bdpart_new_record>       
400048f4:	94 07 bf f0 	add  %fp, -16, %o2                             
      if (sc != RTEMS_SUCCESSFUL) {                                   
400048f8:	80 a2 20 00 	cmp  %o0, 0                                    
400048fc:	12 80 00 34 	bne  400049cc <rtems_bdpart_write+0x4b0>       <== NEVER TAKEN
40004900:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
40004904:	c4 04 60 04 	ld  [ %l1 + 4 ], %g2                           
        block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,              
40004908:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
4000490c:	c2 04 40 00 	ld  [ %l1 ], %g1                               
  if (block != NULL) {                                                
    rtems_bdbuf_sync( block);                                         
  }                                                                   
                                                                      
  return esc;                                                         
}                                                                     
40004910:	de 0c 60 08 	ldub  [ %l1 + 8 ], %o7                         
        esc = sc;                                                     
        goto cleanup;                                                 
      }                                                               
                                                                      
      /* Write first partition entry */                               
      rtems_bdpart_write_mbr_partition(                               
40004914:	f0 0c 60 2f 	ldub  [ %l1 + 0x2f ], %i0                      
40004918:	84 20 80 01 	sub  %g2, %g1, %g2                             
    data [i] = (uint8_t) value;                                       
4000491c:	f8 28 e1 c6 	stb  %i4, [ %g3 + 0x1c6 ]                      
40004920:	c0 28 e1 c7 	clrb  [ %g3 + 0x1c7 ]                          
40004924:	c0 28 e1 c8 	clrb  [ %g3 + 0x1c8 ]                          
40004928:	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);
4000492c:	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) {                                           
40004930:	82 10 20 00 	clr  %g1                                       
    data [i] = (uint8_t) value;                                       
40004934:	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) {                                           
40004938:	82 00 60 01 	inc  %g1                                       
4000493c:	80 a0 60 04 	cmp  %g1, 4                                    
40004940:	12 bf ff fd 	bne  40004934 <rtems_bdpart_write+0x418>       
40004944:	85 30 a0 08 	srl  %g2, 8, %g2                               
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
40004948:	de 28 e1 c2 	stb  %o7, [ %g3 + 0x1c2 ]                      
      RTEMS_BDPART_MBR_EXTENDED,                                      
      0                                                               
    );                                                                
                                                                      
    /* Write logical partitions */                                    
    for (i = ppc; i < count; ++i) {                                   
4000494c:	80 a4 80 1b 	cmp  %l2, %i3                                  
40004950:	02 80 00 21 	be  400049d4 <rtems_bdpart_write+0x4b8>        
40004954:	f0 28 e1 be 	stb  %i0, [ %g3 + 0x1be ]                      
      const rtems_bdpart_partition *p = pt + i;                       
                                                                      
      /* Write second partition entry */                              
      if (i > ppc) {                                                  
40004958:	80 a4 00 12 	cmp  %l0, %l2                                  
4000495c:	1a 80 00 19 	bcc  400049c0 <rtems_bdpart_write+0x4a4>       <== NEVER TAKEN
40004960:	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,            
40004964:	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;            
40004968:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
        rtems_bdpart_write_mbr_partition(                             
          block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,            
4000496c:	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(                             
40004970:	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;            
40004974:	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);
40004978:	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(                             
4000497c:	86 20 40 1d 	sub  %g1, %i5, %g3                             
40004980:	84 20 80 01 	sub  %g2, %g1, %g2                             
40004984:	82 10 20 00 	clr  %g1                                       
    data [i] = (uint8_t) value;                                       
40004988:	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) {                                           
4000498c:	82 00 60 01 	inc  %g1                                       
40004990:	80 a0 60 04 	cmp  %g1, 4                                    
40004994:	12 bf ff fd 	bne  40004988 <rtems_bdpart_write+0x46c>       
40004998:	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);
4000499c:	86 06 21 da 	add  %i0, 0x1da, %g3                           
400049a0:	82 10 20 00 	clr  %g1                                       
    data [i] = (uint8_t) value;                                       
400049a4:	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) {                                           
400049a8:	82 00 60 01 	inc  %g1                                       
400049ac:	80 a0 60 04 	cmp  %g1, 4                                    
400049b0:	12 bf ff fd 	bne  400049a4 <rtems_bdpart_write+0x488>       
400049b4:	85 30 a0 08 	srl  %g2, 8, %g2                               
  data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;                         
400049b8:	f2 2e 21 d2 	stb  %i1, [ %i0 + 0x1d2 ]                      
  data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;                       
400049bc:	c0 2e 21 ce 	clrb  [ %i0 + 0x1ce ]                          
400049c0:	a4 04 a0 01 	inc  %l2                                       
400049c4:	10 bf ff c8 	b  400048e4 <rtems_bdpart_write+0x3c8>         
400049c8:	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) {                                   
400049cc:	10 bf ff 26 	b  40004664 <rtems_bdpart_write+0x148>         <== NOT EXECUTED
400049d0:	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;                           
400049d4:	10 bf ff 24 	b  40004664 <rtems_bdpart_write+0x148>         
400049d8:	b0 10 20 00 	clr  %i0                                       
                                                                      

40004608 <rtems_blkdev_create_partition>: const char *partition, const char *parent_block_device, rtems_blkdev_bnum media_block_begin, rtems_blkdev_bnum media_block_count ) {
40004608:	9d e3 bf 50 	save  %sp, -176, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  int fd = open(parent_block_device, O_RDWR);                         
4000460c:	92 10 20 02 	mov  2, %o1                                    
40004610:	90 10 00 19 	mov  %i1, %o0                                  
40004614:	40 00 09 a0 	call  40006c94 <open>                          
40004618:	b8 10 00 18 	mov  %i0, %i4                                  
                                                                      
    if (sc != RTEMS_SUCCESSFUL) {                                     
      close(fd);                                                      
    }                                                                 
  } else {                                                            
    sc = RTEMS_INVALID_ID;                                            
4000461c:	b0 10 20 04 	mov  4, %i0                                    
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  int fd = open(parent_block_device, O_RDWR);                         
                                                                      
  if (fd >= 0) {                                                      
40004620:	80 a2 20 00 	cmp  %o0, 0                                    
40004624:	06 80 00 0a 	bl  4000464c <rtems_blkdev_create_partition+0x44>
40004628:	ba 10 00 08 	mov  %o0, %i5                                  
    int rv;                                                           
    struct stat st;                                                   
                                                                      
    rv = fstat(fd, &st);                                              
4000462c:	40 00 06 12 	call  40005e74 <fstat>                         
40004630:	92 07 bf b8 	add  %fp, -72, %o1                             
    if (rv == 0 && S_ISBLK(st.st_mode)) {                             
40004634:	80 a2 20 00 	cmp  %o0, 0                                    
40004638:	02 80 00 07 	be  40004654 <rtems_blkdev_create_partition+0x4c><== ALWAYS TAKEN
4000463c:	f2 07 bf c4 	ld  [ %fp + -60 ], %i1                         
40004640:	b0 10 20 15 	mov  0x15, %i0                                 <== NOT EXECUTED
    } else {                                                          
      sc = RTEMS_INVALID_NODE;                                        
    }                                                                 
                                                                      
    if (sc != RTEMS_SUCCESSFUL) {                                     
      close(fd);                                                      
40004644:	40 00 05 c0 	call  40005d44 <close>                         
40004648:	90 10 00 1d 	mov  %i5, %o0                                  
4000464c:	81 c7 e0 08 	ret                                            
40004650:	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)) {                             
40004654:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
40004658:	b2 0e 40 01 	and  %i1, %g1, %i1                             
4000465c:	03 00 00 18 	sethi  %hi(0x6000), %g1                        
40004660:	80 a6 40 01 	cmp  %i1, %g1                                  
40004664:	12 bf ff f8 	bne  40004644 <rtems_blkdev_create_partition+0x3c>
40004668:	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);                   
4000466c:	90 10 00 1d 	mov  %i5, %o0                                  
40004670:	94 07 bf b4 	add  %fp, -76, %o2                             
40004674:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
          }                                                           
        } else {                                                      
          sc = RTEMS_NO_MEMORY;                                       
        }                                                             
      } else {                                                        
        sc = RTEMS_NOT_IMPLEMENTED;                                   
40004678:	b0 10 20 18 	mov  0x18, %i0                                 
4000467c:	40 00 06 54 	call  40005fcc <ioctl>                         
40004680:	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) {                                                  
40004684:	80 a2 20 00 	cmp  %o0, 0                                    
40004688:	12 bf ff ef 	bne  40004644 <rtems_blkdev_create_partition+0x3c>
4000468c:	01 00 00 00 	nop                                            
        rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));        
40004690:	40 00 07 6c 	call  40006440 <malloc>                        
40004694:	90 10 20 80 	mov  0x80, %o0	! 80 <PROM_START+0x80>          
                                                                      
        if (ctx != NULL) {                                            
40004698:	a0 92 20 00 	orcc  %o0, 0, %l0                              
4000469c:	02 80 00 17 	be  400046f8 <rtems_blkdev_create_partition+0xf0>
400046a0:	d2 07 bf b4 	ld  [ %fp + -76 ], %o1                         
          sc = rtems_disk_init_log(                                   
400046a4:	94 10 00 1a 	mov  %i2, %o2                                  
400046a8:	40 00 00 96 	call  40004900 <rtems_disk_init_log>           
400046ac:	96 10 00 1b 	mov  %i3, %o3                                  
            phys_dd,                                                  
            media_block_begin,                                        
            media_block_count                                         
          );                                                          
                                                                      
          if (sc == RTEMS_SUCCESSFUL) {                               
400046b0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400046b4:	12 80 00 0e 	bne  400046ec <rtems_blkdev_create_partition+0xe4>
400046b8:	90 10 00 1c 	mov  %i4, %o0                                  
            ctx->fd = fd;                                             
400046bc:	fa 24 20 78 	st  %i5, [ %l0 + 0x78 ]                        
                                                                      
            rv = IMFS_make_generic_node(                              
400046c0:	92 16 61 ff 	or  %i1, 0x1ff, %o1                            
400046c4:	96 10 00 10 	mov  %l0, %o3                                  
400046c8:	15 10 00 6d 	sethi  %hi(0x4001b400), %o2                    
400046cc:	40 00 03 cb 	call  400055f8 <IMFS_make_generic_node>        
400046d0:	94 12 a0 78 	or  %o2, 0x78, %o2	! 4001b478 <rtems_blkdev_imfs_control>
              S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,                  
              &rtems_blkdev_imfs_control,                             
              ctx                                                     
            );                                                        
                                                                      
            if (rv != 0) {                                            
400046d4:	80 a2 20 00 	cmp  %o0, 0                                    
400046d8:	02 bf ff dd 	be  4000464c <rtems_blkdev_create_partition+0x44>
400046dc:	90 10 00 10 	mov  %l0, %o0                                  
              free(ctx);                                              
400046e0:	40 00 05 bb 	call  40005dcc <free>                          
400046e4:	b0 10 20 0d 	mov  0xd, %i0                                  
400046e8:	30 bf ff d7 	b,a   40004644 <rtems_blkdev_create_partition+0x3c>
              sc = RTEMS_UNSATISFIED;                                 
            }                                                         
          } else {                                                    
            free(ctx);                                                
400046ec:	40 00 05 b8 	call  40005dcc <free>                          
400046f0:	90 10 00 10 	mov  %l0, %o0                                  
400046f4:	30 bf ff d4 	b,a   40004644 <rtems_blkdev_create_partition+0x3c>
          }                                                           
        } else {                                                      
          sc = RTEMS_NO_MEMORY;                                       
400046f8:	10 bf ff d3 	b  40004644 <rtems_blkdev_create_partition+0x3c>
400046fc:	b0 10 20 1a 	mov  0x1a, %i0                                 
                                                                      

40010ab8 <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) {
40010ab8:	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;                               
40010abc:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
    if (args->command != RTEMS_BLKIO_REQUEST)                         
40010ac0:	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;                               
40010ac4:	d0 00 60 30 	ld  [ %g1 + 0x30 ], %o0                        
                                                                      
    if (args->command != RTEMS_BLKIO_REQUEST)                         
40010ac8:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
40010acc:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <LEON_REG+0x40184201>
40010ad0:	80 a2 40 01 	cmp  %o1, %g1                                  
40010ad4:	12 80 00 05 	bne  40010ae8 <rtems_blkdev_generic_ioctl+0x30><== ALWAYS TAKEN
40010ad8:	82 10 3f ff 	mov  -1, %g1                                   
    {                                                                 
        /*                                                            
         * It is not allowed to directly access the driver circumventing the
         * cache.                                                     
         */                                                           
        args->ioctl_return = -1;                                      
40010adc:	c2 26 a0 0c 	st  %g1, [ %i2 + 0xc ]                         <== NOT EXECUTED
    }                                                                 
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40010ae0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40010ae4:	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,                            
40010ae8:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
40010aec:	d4 06 a0 08 	ld  [ %i2 + 8 ], %o2                           
40010af0:	9f c0 40 00 	call  %g1                                      
40010af4:	b0 10 20 00 	clr  %i0                                       
40010af8:	d0 26 a0 0c 	st  %o0, [ %i2 + 0xc ]                         
         */                                                           
        args->ioctl_return = -1;                                      
    }                                                                 
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40010afc:	81 c7 e0 08 	ret                                            
40010b00:	81 e8 00 00 	restore                                        
                                                                      

40010874 <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) {
40010874:	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;                               
40010878:	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);
4001087c:	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;                               
40010880:	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);
40010884:	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;                             
40010888:	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);
4001088c:	90 10 00 1c 	mov  %i4, %o0                                  
40010890:	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;                                     
40010894:	f6 06 a0 14 	ld  [ %i2 + 0x14 ], %i3                        
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
40010898:	40 00 21 e5 	call  4001902c <__divdi3>                      
4001089c:	92 10 00 1d 	mov  %i5, %o1                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
400108a0:	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);
400108a4:	b2 10 00 09 	mov  %o1, %i1                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
400108a8:	94 10 20 00 	clr  %o2                                       
400108ac:	92 10 00 1d 	mov  %i5, %o1                                  
400108b0:	40 00 22 ca 	call  400193d8 <__moddi3>                      
400108b4:	96 10 00 11 	mov  %l1, %o3                                  
                                                                      
    args->bytes_moved = 0;                                            
400108b8:	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);         
400108bc:	a0 10 00 09 	mov  %o1, %l0                                  
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
400108c0:	80 a6 e0 00 	cmp  %i3, 0                                    
400108c4:	12 80 00 1a 	bne  4001092c <rtems_blkdev_generic_read+0xb8> <== ALWAYS TAKEN
400108c8:	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;                          
400108cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400108d0:	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;                                   
400108d4:	ba 24 40 10 	sub  %l1, %l0, %i5                             
400108d8:	80 a7 40 1b 	cmp  %i5, %i3                                  
        if (copy > count)                                             
            copy = count;                                             
        memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);          
400108dc:	08 80 00 03 	bleu  400108e8 <rtems_blkdev_generic_read+0x74><== ALWAYS TAKEN
400108e0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400108e4:	ba 10 00 1b 	mov  %i3, %i5                                  <== NOT EXECUTED
400108e8:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
400108ec:	94 10 00 1d 	mov  %i5, %o2                                  
400108f0:	40 00 14 b9 	call  40015bd4 <memcpy>                        
400108f4:	92 02 40 10 	add  %o1, %l0, %o1                             
        rc = rtems_bdbuf_release(diskbuf);                            
400108f8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
400108fc:	7f ff fd e9 	call  400100a0 <rtems_bdbuf_release>           
40010900:	b8 07 00 1d 	add  %i4, %i5, %i4                             
        args->bytes_moved += copy;                                    
40010904:	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);                            
40010908:	b0 10 00 08 	mov  %o0, %i0                                  
        args->bytes_moved += copy;                                    
4001090c:	82 00 40 1d 	add  %g1, %i5, %g1                             
        if (rc != RTEMS_SUCCESSFUL)                                   
40010910:	80 a2 20 00 	cmp  %o0, 0                                    
40010914:	12 80 00 0e 	bne  4001094c <rtems_blkdev_generic_read+0xd8> <== NEVER TAKEN
40010918:	c2 26 a0 1c 	st  %g1, [ %i2 + 0x1c ]                        
            break;                                                    
        count -= copy;                                                
        buf += copy;                                                  
        blkofs = 0;                                                   
        block++;                                                      
4001091c:	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)                                                 
40010920:	b6 a6 c0 1d 	subcc  %i3, %i5, %i3                           
40010924:	02 80 00 0c 	be  40010954 <rtems_blkdev_generic_read+0xe0>  <== ALWAYS TAKEN
40010928:	a0 10 20 00 	clr  %l0                                       
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        rc = rtems_bdbuf_read(dd, block, &diskbuf);                   
4001092c:	92 10 00 19 	mov  %i1, %o1                                  
40010930:	94 07 bf fc 	add  %fp, -4, %o2                              
40010934:	7f ff fd 56 	call  4000fe8c <rtems_bdbuf_read>              
40010938:	90 10 00 12 	mov  %l2, %o0                                  
4001093c:	b0 10 00 08 	mov  %o0, %i0                                  
        if (rc != RTEMS_SUCCESSFUL)                                   
40010940:	80 a6 20 00 	cmp  %i0, 0                                    
40010944:	02 bf ff e4 	be  400108d4 <rtems_blkdev_generic_read+0x60>  <== ALWAYS TAKEN
40010948:	90 10 00 1c 	mov  %i4, %o0                                  
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
4001094c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40010950:	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;                          
40010954:	b0 10 20 00 	clr  %i0                                       
40010958:	81 c7 e0 08 	ret                                            
4001095c:	81 e8 00 00 	restore                                        
                                                                      

40010960 <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) {
40010960:	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;                               
40010964:	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);
40010968:	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;                               
4001096c:	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);
40010970:	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;                             
40010974:	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);
40010978:	90 10 00 1c 	mov  %i4, %o0                                  
4001097c:	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;                                     
40010980:	f6 06 a0 14 	ld  [ %i2 + 0x14 ], %i3                        
    rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
40010984:	40 00 21 aa 	call  4001902c <__divdi3>                      
40010988:	92 10 00 1d 	mov  %i5, %o1                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
4001098c:	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);
40010990:	b0 10 00 09 	mov  %o1, %i0                                  
    uint32_t blkofs = (uint32_t) (args->offset % block_size);         
40010994:	94 10 20 00 	clr  %o2                                       
40010998:	92 10 00 1d 	mov  %i5, %o1                                  
4001099c:	40 00 22 8f 	call  400193d8 <__moddi3>                      
400109a0:	96 10 00 10 	mov  %l0, %o3                                  
                                                                      
    args->bytes_moved = 0;                                            
400109a4:	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);         
400109a8:	b8 10 00 09 	mov  %o1, %i4                                  
                                                                      
    args->bytes_moved = 0;                                            
                                                                      
    while (count > 0)                                                 
400109ac:	80 a6 e0 00 	cmp  %i3, 0                                    
400109b0:	12 80 00 21 	bne  40010a34 <rtems_blkdev_generic_write+0xd4><== ALWAYS TAKEN
400109b4:	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;                          
400109b8:	10 80 00 2c 	b  40010a68 <rtems_blkdev_generic_write+0x108> <== NOT EXECUTED
400109bc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    while (count > 0)                                                 
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        if ((blkofs == 0) && (count >= block_size))                   
400109c0:	12 80 00 21 	bne  40010a44 <rtems_blkdev_generic_write+0xe4><== NEVER TAKEN
400109c4:	92 10 00 18 	mov  %i0, %o1                                  
            rc = rtems_bdbuf_get(dd, block, &diskbuf);                
400109c8:	90 10 00 11 	mov  %l1, %o0                                  
400109cc:	7f ff fc f0 	call  4000fd8c <rtems_bdbuf_get>               
400109d0:	94 07 bf fc 	add  %fp, -4, %o2                              
        else                                                          
            rc = rtems_bdbuf_read(dd, block, &diskbuf);               
        if (rc != RTEMS_SUCCESSFUL)                                   
400109d4:	80 a2 20 00 	cmp  %o0, 0                                    
400109d8:	12 80 00 21 	bne  40010a5c <rtems_blkdev_generic_write+0xfc><== NEVER TAKEN
400109dc:	92 10 00 19 	mov  %i1, %o1                                  
            break;                                                    
                                                                      
        copy = block_size - blkofs;                                   
400109e0:	ba 24 00 1c 	sub  %l0, %i4, %i5                             
400109e4:	80 a7 40 1b 	cmp  %i5, %i3                                  
        if (copy > count)                                             
            copy = count;                                             
        memcpy((char *)diskbuf->buffer + blkofs, buf, copy);          
400109e8:	08 80 00 03 	bleu  400109f4 <rtems_blkdev_generic_write+0x94><== ALWAYS TAKEN
400109ec:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400109f0:	ba 10 00 1b 	mov  %i3, %i5                                  <== NOT EXECUTED
400109f4:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
400109f8:	94 10 00 1d 	mov  %i5, %o2                                  
400109fc:	40 00 14 76 	call  40015bd4 <memcpy>                        
40010a00:	90 02 00 1c 	add  %o0, %i4, %o0                             
        args->bytes_moved += copy;                                    
40010a04:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
                                                                      
        rc = rtems_bdbuf_release_modified(diskbuf);                   
40010a08:	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;                                    
40010a0c:	82 00 40 1d 	add  %g1, %i5, %g1                             
        rc = rtems_bdbuf_release_modified(diskbuf);                   
        if (rc != RTEMS_SUCCESSFUL)                                   
            break;                                                    
                                                                      
        count -= copy;                                                
        buf += copy;                                                  
40010a10:	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);                   
40010a14:	7f ff fd db 	call  40010180 <rtems_bdbuf_release_modified>  
40010a18:	c2 26 a0 1c 	st  %g1, [ %i2 + 0x1c ]                        
        if (rc != RTEMS_SUCCESSFUL)                                   
40010a1c:	80 a2 20 00 	cmp  %o0, 0                                    
40010a20:	12 80 00 0f 	bne  40010a5c <rtems_blkdev_generic_write+0xfc><== NEVER TAKEN
40010a24:	b6 a6 c0 1d 	subcc  %i3, %i5, %i3                           
            break;                                                    
                                                                      
        count -= copy;                                                
        buf += copy;                                                  
        blkofs = 0;                                                   
        block++;                                                      
40010a28:	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)                                                 
40010a2c:	02 80 00 0e 	be  40010a64 <rtems_blkdev_generic_write+0x104><== ALWAYS TAKEN
40010a30:	b8 10 20 00 	clr  %i4                                       
    {                                                                 
        rtems_bdbuf_buffer *diskbuf;                                  
        uint32_t            copy;                                     
                                                                      
        if ((blkofs == 0) && (count >= block_size))                   
40010a34:	80 a6 c0 10 	cmp  %i3, %l0                                  
40010a38:	1a bf ff e2 	bcc  400109c0 <rtems_blkdev_generic_write+0x60><== ALWAYS TAKEN
40010a3c:	80 a7 20 00 	cmp  %i4, 0                                    
            rc = rtems_bdbuf_get(dd, block, &diskbuf);                
        else                                                          
            rc = rtems_bdbuf_read(dd, block, &diskbuf);               
40010a40:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
40010a44:	94 07 bf fc 	add  %fp, -4, %o2                              <== NOT EXECUTED
40010a48:	7f ff fd 11 	call  4000fe8c <rtems_bdbuf_read>              <== NOT EXECUTED
40010a4c:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
        if (rc != RTEMS_SUCCESSFUL)                                   
40010a50:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40010a54:	02 bf ff e3 	be  400109e0 <rtems_blkdev_generic_write+0x80> <== NOT EXECUTED
40010a58:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
40010a5c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40010a60:	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;                          
40010a64:	90 10 20 00 	clr  %o0                                       
        blkofs = 0;                                                   
        block++;                                                      
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
40010a68:	81 c7 e0 08 	ret                                            
40010a6c:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

400044e4 <rtems_blkdev_imfs_fsync_or_fdatasync>: } static int rtems_blkdev_imfs_fsync_or_fdatasync( rtems_libio_t *iop ) {
400044e4:	9d e3 bf a0 	save  %sp, -96, %sp                            
400044e8:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
  int rv = 0;                                                         
400044ec:	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);                     
400044f0:	40 00 32 93 	call  40010f3c <rtems_bdbuf_syncdev>           
400044f4:	d0 00 60 50 	ld  [ %g1 + 0x50 ], %o0                        
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
400044f8:	80 a2 20 00 	cmp  %o0, 0                                    
400044fc:	12 80 00 04 	bne  4000450c <rtems_blkdev_imfs_fsync_or_fdatasync+0x28><== NEVER TAKEN
40004500:	01 00 00 00 	nop                                            
    errno = EIO;                                                      
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40004504:	81 c7 e0 08 	ret                                            
40004508:	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;                                                      
4000450c:	40 00 45 16 	call  40015964 <__errno>                       <== NOT EXECUTED
40004510:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40004514:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40004518:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
4000451c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004520:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40004524 <rtems_blkdev_imfs_ioctl>: static int rtems_blkdev_imfs_ioctl( rtems_libio_t *iop, uint32_t request, void *buffer ) {
40004524:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  if (request != RTEMS_BLKIO_REQUEST) {                               
40004528:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
4000452c:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <LEON_REG+0x40184201>
40004530:	80 a6 40 01 	cmp  %i1, %g1                                  
40004534:	02 80 00 09 	be  40004558 <rtems_blkdev_imfs_ioctl+0x34>    <== NEVER TAKEN
40004538:	92 10 00 19 	mov  %i1, %o1                                  
4000453c:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
40004540:	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);                           
40004544:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
40004548:	9f c0 40 00 	call  %g1                                      
4000454c:	94 10 00 1a 	mov  %i2, %o2                                  
40004550:	81 c7 e0 08 	ret                                            
40004554:	91 e8 00 08 	restore  %g0, %o0, %o0                         
  } else {                                                            
    /*                                                                
     * It is not allowed to directly access the driver circumventing the cache.
     */                                                               
    errno = EINVAL;                                                   
40004558:	40 00 45 03 	call  40015964 <__errno>                       <== NOT EXECUTED
4000455c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40004560:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40004564:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40004568:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000456c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40004358 <rtems_blkdev_imfs_read>: static ssize_t rtems_blkdev_imfs_read( rtems_libio_t *iop, void *buffer, size_t count ) {
40004358:	9d e3 bf 98 	save  %sp, -104, %sp                           
4000435c:	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;                                         
40004360:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
40004364:	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);
40004368:	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);       
4000436c:	e4 04 60 24 	ld  [ %l1 + 0x24 ], %l2                        
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
40004370:	90 10 00 1c 	mov  %i4, %o0                                  
40004374:	a1 3c a0 1f 	sra  %l2, 0x1f, %l0                            
40004378:	96 10 00 12 	mov  %l2, %o3                                  
4000437c:	40 00 55 28 	call  4001981c <__divdi3>                      
40004380:	94 10 00 10 	mov  %l0, %o2                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
40004384:	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);
40004388:	b6 10 00 09 	mov  %o1, %i3                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
4000438c:	90 10 00 1c 	mov  %i4, %o0                                  
40004390:	92 10 00 1d 	mov  %i5, %o1                                  
40004394:	40 00 56 0d 	call  40019bc8 <__moddi3>                      
40004398:	96 10 00 12 	mov  %l2, %o3                                  
  char *dst = buffer;                                                 
                                                                      
  while (remaining > 0) {                                             
4000439c:	ba 96 a0 00 	orcc  %i2, 0, %i5                              
400043a0:	04 80 00 23 	ble  4000442c <rtems_blkdev_imfs_read+0xd4>    <== NEVER TAKEN
400043a4:	a0 10 00 09 	mov  %o1, %l0                                  
    rtems_bdbuf_buffer *bd;                                           
    rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);          
400043a8:	92 10 00 1b 	mov  %i3, %o1                                  
400043ac:	94 07 bf fc 	add  %fp, -4, %o2                              
400043b0:	40 00 31 b4 	call  40010a80 <rtems_bdbuf_read>              
400043b4:	90 10 00 11 	mov  %l1, %o0                                  
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
400043b8:	80 a2 20 00 	cmp  %o0, 0                                    
400043bc:	02 80 00 09 	be  400043e0 <rtems_blkdev_imfs_read+0x88>     <== ALWAYS TAKEN
400043c0:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
  if (remaining >= 0) {                                               
    iop->offset += count;                                             
    rv = (ssize_t) count;                                             
  } else {                                                            
    errno = EIO;                                                      
400043c4:	40 00 45 68 	call  40015964 <__errno>                       <== NOT EXECUTED
400043c8:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rv = -1;                                                          
400043cc:	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;                                                      
400043d0:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
400043d4:	c4 22 00 00 	st  %g2, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400043d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400043dc:	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;                       
400043e0:	b8 24 80 10 	sub  %l2, %l0, %i4                             
400043e4:	80 a7 00 1d 	cmp  %i4, %i5                                  
                                                                      
      if (copy > remaining) {                                         
        copy = remaining;                                             
      }                                                               
                                                                      
      memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy); 
400043e8:	04 80 00 03 	ble  400043f4 <rtems_blkdev_imfs_read+0x9c>    
400043ec:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400043f0:	b8 10 00 1d 	mov  %i5, %i4                                  
400043f4:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
400043f8:	94 10 00 1c 	mov  %i4, %o2                                  
400043fc:	40 00 47 bb 	call  400162e8 <memcpy>                        
40004400:	92 02 40 10 	add  %o1, %l0, %o1                             
                                                                      
      sc = rtems_bdbuf_release(bd);                                   
40004404:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
40004408:	40 00 32 23 	call  40010c94 <rtems_bdbuf_release>           
4000440c:	ba 27 40 1c 	sub  %i5, %i4, %i5                             
      if (sc == RTEMS_SUCCESSFUL) {                                   
40004410:	80 a2 20 00 	cmp  %o0, 0                                    
40004414:	12 bf ff ec 	bne  400043c4 <rtems_blkdev_imfs_read+0x6c>    <== NEVER TAKEN
40004418:	80 a7 60 00 	cmp  %i5, 0                                    
        block_offset = 0;                                             
        remaining -= copy;                                            
        dst += copy;                                                  
4000441c:	b2 06 40 1c 	add  %i1, %i4, %i1                             
        ++block;                                                      
40004420:	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) {                                             
40004424:	14 bf ff e1 	bg  400043a8 <rtems_blkdev_imfs_read+0x50>     
40004428:	a0 10 20 00 	clr  %l0                                       
    } else {                                                          
      remaining = -1;                                                 
    }                                                                 
  }                                                                   
                                                                      
  if (remaining >= 0) {                                               
4000442c:	80 a7 60 00 	cmp  %i5, 0                                    
40004430:	12 bf ff e5 	bne  400043c4 <rtems_blkdev_imfs_read+0x6c>    <== NEVER TAKEN
40004434:	82 10 00 1a 	mov  %i2, %g1                                  
    iop->offset += count;                                             
40004438:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
4000443c:	86 80 c0 1a 	addcc  %g3, %i2, %g3                           
40004440:	84 40 a0 00 	addx  %g2, 0, %g2                              
40004444:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
    errno = EIO;                                                      
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40004448:	81 c7 e0 08 	ret                                            
4000444c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

40004224 <rtems_blkdev_imfs_write>: static ssize_t rtems_blkdev_imfs_write( rtems_libio_t *iop, const void *buffer, size_t count ) {
40004224:	9d e3 bf 98 	save  %sp, -104, %sp                           
40004228:	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;                                         
4000422c:	f8 1e 20 08 	ldd  [ %i0 + 8 ], %i4                          
40004230:	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);
40004234:	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);       
40004238:	f6 04 60 24 	ld  [ %l1 + 0x24 ], %i3                        
  rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
4000423c:	90 10 00 1c 	mov  %i4, %o0                                  
40004240:	a1 3e e0 1f 	sra  %i3, 0x1f, %l0                            
40004244:	96 10 00 1b 	mov  %i3, %o3                                  
40004248:	40 00 55 75 	call  4001981c <__divdi3>                      
4000424c:	94 10 00 10 	mov  %l0, %o2                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
40004250:	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);
40004254:	a4 10 00 09 	mov  %o1, %l2                                  
  ssize_t block_offset = (ssize_t) (offset % block_size);             
40004258:	90 10 00 1c 	mov  %i4, %o0                                  
4000425c:	92 10 00 1d 	mov  %i5, %o1                                  
40004260:	40 00 56 5a 	call  40019bc8 <__moddi3>                      
40004264:	96 10 00 1b 	mov  %i3, %o3                                  
  const char *src = buffer;                                           
                                                                      
  while (remaining > 0) {                                             
40004268:	ba 96 a0 00 	orcc  %i2, 0, %i5                              
4000426c:	04 80 00 2e 	ble  40004324 <rtems_blkdev_imfs_write+0x100>  <== NEVER TAKEN
40004270:	a0 10 00 09 	mov  %o1, %l0                                  
    rtems_status_code sc;                                             
    rtems_bdbuf_buffer *bd;                                           
                                                                      
    if (block_offset == 0 && remaining >= block_size) {               
40004274:	80 a7 40 1b 	cmp  %i5, %i3                                  
40004278:	16 80 00 03 	bge  40004284 <rtems_blkdev_imfs_write+0x60>   
4000427c:	82 10 20 01 	mov  1, %g1                                    
40004280:	82 10 20 00 	clr  %g1                                       
       sc = rtems_bdbuf_get(dd, block, &bd);                          
40004284:	90 10 00 11 	mov  %l1, %o0                                  
40004288:	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) {               
4000428c:	80 88 60 ff 	btst  0xff, %g1                                
40004290:	02 80 00 2e 	be  40004348 <rtems_blkdev_imfs_write+0x124>   
40004294:	94 07 bf fc 	add  %fp, -4, %o2                              
40004298:	80 a4 20 00 	cmp  %l0, 0                                    
4000429c:	12 80 00 2b 	bne  40004348 <rtems_blkdev_imfs_write+0x124>  
400042a0:	01 00 00 00 	nop                                            
       sc = rtems_bdbuf_get(dd, block, &bd);                          
400042a4:	40 00 31 b7 	call  40010980 <rtems_bdbuf_get>               
400042a8:	01 00 00 00 	nop                                            
    } else {                                                          
       sc = rtems_bdbuf_read(dd, block, &bd);                         
    }                                                                 
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
400042ac:	80 a2 20 00 	cmp  %o0, 0                                    
400042b0:	02 80 00 09 	be  400042d4 <rtems_blkdev_imfs_write+0xb0>    <== ALWAYS TAKEN
400042b4:	b8 26 c0 10 	sub  %i3, %l0, %i4                             
                                                                      
  if (remaining >= 0) {                                               
    iop->offset += count;                                             
    rv = (ssize_t) count;                                             
  } else {                                                            
    errno = EIO;                                                      
400042b8:	40 00 45 ab 	call  40015964 <__errno>                       <== NOT EXECUTED
400042bc:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rv = -1;                                                          
400042c0:	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;                                                      
400042c4:	84 10 20 05 	mov  5, %g2                                    <== NOT EXECUTED
400042c8:	c4 22 00 00 	st  %g2, [ %o0 ]                               <== NOT EXECUTED
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
400042cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400042d0:	91 e8 00 01 	restore  %g0, %g1, %o0                         <== NOT EXECUTED
400042d4:	80 a7 00 1d 	cmp  %i4, %i5                                  
400042d8:	34 80 00 02 	bg,a   400042e0 <rtems_blkdev_imfs_write+0xbc> 
400042dc:	b8 10 00 1d 	mov  %i5, %i4                                  
                                                                      
      if (copy > remaining) {                                         
        copy = remaining;                                             
      }                                                               
                                                                      
      memcpy((char *) bd->buffer + block_offset, src, (size_t) copy); 
400042e0:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400042e4:	92 10 00 19 	mov  %i1, %o1                                  
400042e8:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
400042ec:	94 10 00 1c 	mov  %i4, %o2                                  
400042f0:	40 00 47 fe 	call  400162e8 <memcpy>                        
400042f4:	90 02 00 10 	add  %o0, %l0, %o0                             
                                                                      
      sc = rtems_bdbuf_release_modified(bd);                          
400042f8:	40 00 32 9f 	call  40010d74 <rtems_bdbuf_release_modified>  
400042fc:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
      if (sc == RTEMS_SUCCESSFUL) {                                   
40004300:	80 a2 20 00 	cmp  %o0, 0                                    
40004304:	12 bf ff ed 	bne  400042b8 <rtems_blkdev_imfs_write+0x94>   <== NEVER TAKEN
40004308:	01 00 00 00 	nop                                            
        block_offset = 0;                                             
        remaining -= copy;                                            
4000430c:	ba 27 40 1c 	sub  %i5, %i4, %i5                             
        src += copy;                                                  
40004310:	b2 06 40 1c 	add  %i1, %i4, %i1                             
        ++block;                                                      
40004314:	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) {                                             
40004318:	80 a7 60 00 	cmp  %i5, 0                                    
4000431c:	14 bf ff d6 	bg  40004274 <rtems_blkdev_imfs_write+0x50>    
40004320:	a0 10 20 00 	clr  %l0                                       
    } else {                                                          
      remaining = -1;                                                 
    }                                                                 
  }                                                                   
                                                                      
  if (remaining >= 0) {                                               
40004324:	80 a7 60 00 	cmp  %i5, 0                                    
40004328:	12 bf ff e4 	bne  400042b8 <rtems_blkdev_imfs_write+0x94>   <== NEVER TAKEN
4000432c:	82 10 00 1a 	mov  %i2, %g1                                  
    iop->offset += count;                                             
40004330:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
40004334:	86 80 c0 1a 	addcc  %g3, %i2, %g3                           
40004338:	84 40 a0 00 	addx  %g2, 0, %g2                              
4000433c:	c4 3e 20 08 	std  %g2, [ %i0 + 8 ]                          
    errno = EIO;                                                      
    rv = -1;                                                          
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40004340:	81 c7 e0 08 	ret                                            
40004344:	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);                         
40004348:	40 00 31 ce 	call  40010a80 <rtems_bdbuf_read>              
4000434c:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
40004350:	10 bf ff d8 	b  400042b0 <rtems_blkdev_imfs_write+0x8c>     
40004354:	80 a2 20 00 	cmp  %o0, 0                                    
                                                                      

40010704 <rtems_blkdev_ioctl>: #include <rtems/blkdev.h> #include <rtems/bdbuf.h> int rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp) {
40010704:	9d e3 bf a0 	save  %sp, -96, %sp                            
    rtems_status_code  sc;                                            
    int                rc = 0;                                        
                                                                      
    switch (req)                                                      
40010708:	05 10 01 10 	sethi  %hi(0x40044000), %g2                    
4001070c:	82 10 a2 03 	or  %g2, 0x203, %g1	! 40044203 <__end+0x26c33> 
40010710:	80 a6 40 01 	cmp  %i1, %g1                                  
40010714:	22 80 00 55 	be,a   40010868 <rtems_blkdev_ioctl+0x164>     
40010718:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
4001071c:	08 80 00 1c 	bleu  4001078c <rtems_blkdev_ioctl+0x88>       
40010720:	03 08 00 10 	sethi  %hi(0x20004000), %g1                    
40010724:	82 10 a2 09 	or  %g2, 0x209, %g1                            
40010728:	80 a6 40 01 	cmp  %i1, %g1                                  
4001072c:	22 80 00 3c 	be,a   4001081c <rtems_blkdev_ioctl+0x118>     
40010730:	f0 26 80 00 	st  %i0, [ %i2 ]                               
40010734:	28 80 00 27 	bleu,a   400107d0 <rtems_blkdev_ioctl+0xcc>    
40010738:	84 10 a2 05 	or  %g2, 0x205, %g2                            
4001073c:	84 10 a2 0b 	or  %g2, 0x20b, %g2                            
40010740:	80 a6 40 02 	cmp  %i1, %g2                                  
40010744:	02 80 00 3f 	be  40010840 <rtems_blkdev_ioctl+0x13c>        
40010748:	03 20 01 10 	sethi  %hi(0x80044000), %g1                    
4001074c:	82 10 62 04 	or  %g1, 0x204, %g1	! 80044204 <LEON_REG+0x44204>
40010750:	80 a6 40 01 	cmp  %i1, %g1                                  
40010754:	12 80 00 22 	bne  400107dc <rtems_blkdev_ioctl+0xd8>        <== NEVER TAKEN
40010758:	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);
4001075c:	d2 06 80 00 	ld  [ %i2 ], %o1                               
40010760:	7f ff ff 8f 	call  4001059c <rtems_bdbuf_set_block_size>    
40010764:	94 10 20 01 	mov  1, %o2                                    
            if (sc != RTEMS_SUCCESSFUL) {                             
40010768:	80 a2 20 00 	cmp  %o0, 0                                    
4001076c:	02 80 00 2a 	be  40010814 <rtems_blkdev_ioctl+0x110>        <== ALWAYS TAKEN
40010770:	01 00 00 00 	nop                                            
            break;                                                    
                                                                      
        case RTEMS_BLKIO_SYNCDEV:                                     
            sc = rtems_bdbuf_syncdev(dd);                             
            if (sc != RTEMS_SUCCESSFUL) {                             
                errno = EIO;                                          
40010774:	40 00 12 e1 	call  400152f8 <__errno>                       <== NOT EXECUTED
40010778:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
4001077c:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40010780:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40010784:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40010788:	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)                                                      
4001078c:	86 10 62 0a 	or  %g1, 0x20a, %g3                            
40010790:	80 a6 40 03 	cmp  %i1, %g3                                  
40010794:	02 80 00 31 	be  40010858 <rtems_blkdev_ioctl+0x154>        
40010798:	90 10 00 18 	mov  %i0, %o0                                  
4001079c:	28 80 00 16 	bleu,a   400107f4 <rtems_blkdev_ioctl+0xf0>    
400107a0:	82 10 62 06 	or  %g1, 0x206, %g1                            
400107a4:	82 10 62 0c 	or  %g1, 0x20c, %g1                            
400107a8:	80 a6 40 01 	cmp  %i1, %g1                                  
400107ac:	02 80 00 21 	be  40010830 <rtems_blkdev_ioctl+0x12c>        
400107b0:	84 10 a2 02 	or  %g2, 0x202, %g2                            
400107b4:	80 a6 40 02 	cmp  %i1, %g2                                  
400107b8:	12 80 00 09 	bne  400107dc <rtems_blkdev_ioctl+0xd8>        <== NEVER TAKEN
400107bc:	01 00 00 00 	nop                                            
    {                                                                 
        case RTEMS_BLKIO_GETMEDIABLKSIZE:                             
            *(uint32_t *) argp = dd->media_block_size;                
400107c0:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
400107c4:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
400107c8:	81 c7 e0 08 	ret                                            
400107cc:	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)                                                      
400107d0:	80 a6 40 02 	cmp  %i1, %g2                                  
400107d4:	22 80 00 14 	be,a   40010824 <rtems_blkdev_ioctl+0x120>     <== ALWAYS TAKEN
400107d8:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
        case RTEMS_BLKIO_RESETDEVSTATS:                               
            rtems_bdbuf_reset_device_stats(dd);                       
            break;                                                    
                                                                      
        default:                                                      
            errno = EINVAL;                                           
400107dc:	40 00 12 c7 	call  400152f8 <__errno>                       
400107e0:	b0 10 3f ff 	mov  -1, %i0                                   
400107e4:	82 10 20 16 	mov  0x16, %g1                                 
400107e8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
            rc = -1;                                                  
            break;                                                    
    }                                                                 
                                                                      
    return rc;                                                        
}                                                                     
400107ec:	81 c7 e0 08 	ret                                            
400107f0:	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)                                                      
400107f4:	80 a6 40 01 	cmp  %i1, %g1                                  
400107f8:	12 bf ff f9 	bne  400107dc <rtems_blkdev_ioctl+0xd8>        
400107fc:	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);                             
40010800:	7f ff fe d2 	call  40010348 <rtems_bdbuf_syncdev>           
40010804:	90 10 00 18 	mov  %i0, %o0                                  
            if (sc != RTEMS_SUCCESSFUL) {                             
40010808:	80 a2 20 00 	cmp  %o0, 0                                    
4001080c:	12 bf ff da 	bne  40010774 <rtems_blkdev_ioctl+0x70>        <== NEVER TAKEN
40010810:	01 00 00 00 	nop                                            
            }                                                         
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETDISKDEV:                                  
            *(rtems_disk_device **) argp = dd;                        
            break;                                                    
40010814:	81 c7 e0 08 	ret                                            
40010818:	91 e8 20 00 	restore  %g0, 0, %o0                           
4001081c:	81 c7 e0 08 	ret                                            
40010820:	91 e8 20 00 	restore  %g0, 0, %o0                           
                rc = -1;                                              
            }                                                         
            break;                                                    
                                                                      
        case RTEMS_BLKIO_GETSIZE:                                     
            *(rtems_blkdev_bnum *) argp = dd->size;                   
40010824:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
40010828:	81 c7 e0 08 	ret                                            
4001082c:	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);                       
40010830:	7f ff ff ac 	call  400106e0 <rtems_bdbuf_reset_device_stats>
40010834:	b0 10 20 00 	clr  %i0                                       
            break;                                                    
40010838:	81 c7 e0 08 	ret                                            
4001083c:	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);
40010840:	90 10 00 18 	mov  %i0, %o0                                  
40010844:	92 10 00 1a 	mov  %i2, %o1                                  
40010848:	7f ff ff 9d 	call  400106bc <rtems_bdbuf_get_device_stats>  
4001084c:	b0 10 20 00 	clr  %i0                                       
            break;                                                    
40010850:	81 c7 e0 08 	ret                                            
40010854:	81 e8 00 00 	restore                                        
        case RTEMS_BLKIO_GETDISKDEV:                                  
            *(rtems_disk_device **) argp = dd;                        
            break;                                                    
                                                                      
        case RTEMS_BLKIO_PURGEDEV:                                    
            rtems_bdbuf_purge_dev(dd);                                
40010858:	7f ff fe d3 	call  400103a4 <rtems_bdbuf_purge_dev>         
4001085c:	b0 10 20 00 	clr  %i0                                       
            break;                                                    
40010860:	81 c7 e0 08 	ret                                            
40010864:	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;                      
40010868:	c2 26 80 00 	st  %g1, [ %i2 ]                               
            break;                                                    
4001086c:	81 c7 e0 08 	ret                                            
40010870:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40026034 <rtems_blkstats>: #include <fcntl.h> #include <unistd.h> #include <errno.h> void rtems_blkstats(FILE *output, const char *device, bool reset) {
40026034:	9d e3 bf 38 	save  %sp, -200, %sp                           <== NOT EXECUTED
  int fd = open(device, O_RDONLY);                                    
40026038:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4002603c:	7f ff 7a 3c 	call  4000492c <open>                          <== NOT EXECUTED
40026040:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
                                                                      
  if (fd >= 0) {                                                      
40026044:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40026048:	06 80 00 33 	bl  40026114 <rtems_blkstats+0xe0>             <== NOT EXECUTED
4002604c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    struct stat st;                                                   
    int rv;                                                           
                                                                      
    rv = fstat(fd, &st);                                              
40026050:	40 00 07 60 	call  40027dd0 <fstat>                         <== NOT EXECUTED
40026054:	92 07 bf b8 	add  %fp, -72, %o1                             <== NOT EXECUTED
    if (rv == 0) {                                                    
40026058:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4002605c:	12 80 00 39 	bne  40026140 <rtems_blkstats+0x10c>           <== NOT EXECUTED
40026060:	c4 07 bf c4 	ld  [ %fp + -60 ], %g2                         <== NOT EXECUTED
      if (S_ISBLK(st.st_mode)) {                                      
40026064:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        <== NOT EXECUTED
40026068:	84 08 80 01 	and  %g2, %g1, %g2                             <== NOT EXECUTED
4002606c:	03 00 00 18 	sethi  %hi(0x6000), %g1                        <== NOT EXECUTED
40026070:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
40026074:	02 80 00 19 	be  400260d8 <rtems_blkstats+0xa4>             <== NOT EXECUTED
40026078:	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");               
4002607c:	11 10 01 7e 	sethi  %hi(0x4005f800), %o0                    <== NOT EXECUTED
40026080:	90 12 22 68 	or  %o0, 0x268, %o0	! 4005fa68 <RTEMS_BDPART_MBR_MASTER_TYPE+0x40><== NOT EXECUTED
40026084:	94 10 20 1a 	mov  0x1a, %o2                                 <== NOT EXECUTED
40026088:	40 00 61 37 	call  4003e564 <fwrite>                        <== NOT EXECUTED
4002608c:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
      }                                                               
    } else {                                                          
      fprintf(output, "error: get file stats: %s\n", strerror(errno));
    }                                                                 
                                                                      
    rv = close(fd);                                                   
40026090:	40 00 06 2f 	call  4002794c <close>                         <== NOT EXECUTED
40026094:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    if (rv != 0) {                                                    
40026098:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4002609c:	12 80 00 04 	bne  400260ac <rtems_blkstats+0x78>            <== NOT EXECUTED
400260a0:	01 00 00 00 	nop                                            <== NOT EXECUTED
400260a4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400260a8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      fprintf(output, "error: close device: %s\n", strerror(errno));  
400260ac:	40 00 59 af 	call  4003c768 <__errno>                       <== NOT EXECUTED
400260b0:	01 00 00 00 	nop                                            <== NOT EXECUTED
400260b4:	40 00 75 54 	call  40043604 <strerror>                      <== NOT EXECUTED
400260b8:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
400260bc:	13 10 01 7e 	sethi  %hi(0x4005f800), %o1                    <== NOT EXECUTED
400260c0:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
400260c4:	92 12 62 a8 	or  %o1, 0x2a8, %o1                            <== NOT EXECUTED
400260c8:	40 00 5c 6b 	call  4003d274 <fprintf>                       <== NOT EXECUTED
400260cc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400260d0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400260d4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    int rv;                                                           
                                                                      
    rv = fstat(fd, &st);                                              
    if (rv == 0) {                                                    
      if (S_ISBLK(st.st_mode)) {                                      
        if (reset) {                                                  
400260d8:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
400260dc:	12 80 00 23 	bne  40026168 <rtems_blkstats+0x134>           <== NOT EXECUTED
400260e0:	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);                   
400260e4:	94 07 bf 98 	add  %fp, -104, %o2                            <== NOT EXECUTED
400260e8:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    <== NOT EXECUTED
400260ec:	40 00 0a 1d 	call  40028960 <ioctl>                         <== NOT EXECUTED
400260f0:	92 12 62 0b 	or  %o1, 0x20b, %o1	! 4004420b <strptime+0x467><== NOT EXECUTED
          }                                                           
        } else {                                                      
          rtems_blkdev_stats stats;                                   
                                                                      
          rv = rtems_disk_fd_get_device_stats(fd, &stats);            
          if (rv == 0) {                                              
400260f4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400260f8:	12 80 00 2c 	bne  400261a8 <rtems_blkstats+0x174>           <== NOT EXECUTED
400260fc:	13 10 00 f4 	sethi  %hi(0x4003d000), %o1                    <== NOT EXECUTED
            rtems_blkdev_print_stats(                                 
40026100:	90 07 bf 98 	add  %fp, -104, %o0                            <== NOT EXECUTED
40026104:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
40026108:	40 00 00 32 	call  400261d0 <rtems_blkdev_print_stats>      <== NOT EXECUTED
4002610c:	92 12 62 74 	or  %o1, 0x274, %o1                            <== NOT EXECUTED
40026110:	30 bf ff e0 	b,a   40026090 <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));     
40026114:	40 00 59 95 	call  4003c768 <__errno>                       <== NOT EXECUTED
40026118:	01 00 00 00 	nop                                            <== NOT EXECUTED
4002611c:	40 00 75 3a 	call  40043604 <strerror>                      <== NOT EXECUTED
40026120:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40026124:	13 10 01 7e 	sethi  %hi(0x4005f800), %o1                    <== NOT EXECUTED
40026128:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4002612c:	92 12 62 c8 	or  %o1, 0x2c8, %o1                            <== NOT EXECUTED
40026130:	40 00 5c 51 	call  4003d274 <fprintf>                       <== NOT EXECUTED
40026134:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40026138:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4002613c:	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));
40026140:	40 00 59 8a 	call  4003c768 <__errno>                       <== NOT EXECUTED
40026144:	01 00 00 00 	nop                                            <== NOT EXECUTED
40026148:	40 00 75 2f 	call  40043604 <strerror>                      <== NOT EXECUTED
4002614c:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40026150:	13 10 01 7e 	sethi  %hi(0x4005f800), %o1                    <== NOT EXECUTED
40026154:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40026158:	92 12 62 88 	or  %o1, 0x288, %o1                            <== NOT EXECUTED
4002615c:	40 00 5c 46 	call  4003d274 <fprintf>                       <== NOT EXECUTED
40026160:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40026164:	30 bf ff cb 	b,a   40026090 <rtems_blkstats+0x5c>           <== NOT EXECUTED
}                                                                     
                                                                      
static inline int rtems_disk_fd_reset_device_stats(int fd)            
{                                                                     
  return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);                        
40026168:	13 08 00 10 	sethi  %hi(0x20004000), %o1                    <== NOT EXECUTED
4002616c:	40 00 09 fd 	call  40028960 <ioctl>                         <== NOT EXECUTED
40026170:	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) {                                              
40026174:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40026178:	02 bf ff c6 	be  40026090 <rtems_blkstats+0x5c>             <== NOT EXECUTED
4002617c:	01 00 00 00 	nop                                            <== NOT EXECUTED
            fprintf(output, "error: reset stats: %s\n", strerror(errno));
40026180:	40 00 59 7a 	call  4003c768 <__errno>                       <== NOT EXECUTED
40026184:	01 00 00 00 	nop                                            <== NOT EXECUTED
40026188:	40 00 75 1f 	call  40043604 <strerror>                      <== NOT EXECUTED
4002618c:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40026190:	13 10 01 7e 	sethi  %hi(0x4005f800), %o1                    <== NOT EXECUTED
40026194:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40026198:	92 12 62 38 	or  %o1, 0x238, %o1                            <== NOT EXECUTED
4002619c:	40 00 5c 36 	call  4003d274 <fprintf>                       <== NOT EXECUTED
400261a0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400261a4:	30 bf ff bb 	b,a   40026090 <rtems_blkstats+0x5c>           <== NOT EXECUTED
              &stats,                                                 
              (rtems_printk_plugin_t) fprintf,                        
              output                                                  
            );                                                        
          } else {                                                    
            fprintf(output, "error: get stats: %s\n", strerror(errno));
400261a8:	40 00 59 70 	call  4003c768 <__errno>                       <== NOT EXECUTED
400261ac:	01 00 00 00 	nop                                            <== NOT EXECUTED
400261b0:	40 00 75 15 	call  40043604 <strerror>                      <== NOT EXECUTED
400261b4:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
400261b8:	13 10 01 7e 	sethi  %hi(0x4005f800), %o1                    <== NOT EXECUTED
400261bc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
400261c0:	92 12 62 50 	or  %o1, 0x250, %o1                            <== NOT EXECUTED
400261c4:	40 00 5c 2c 	call  4003d274 <fprintf>                       <== NOT EXECUTED
400261c8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400261cc:	30 bf ff b1 	b,a   40026090 <rtems_blkstats+0x5c>           <== NOT EXECUTED
                                                                      

40003b2c <rtems_bsp_cmdline_get_param>: const char *rtems_bsp_cmdline_get_param( const char *name, char *value, size_t length ) {
40003b2c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
40003b30:	80 a6 20 00 	cmp  %i0, 0                                    
40003b34:	02 80 00 36 	be  40003c0c <rtems_bsp_cmdline_get_param+0xe0>
40003b38:	80 a6 60 00 	cmp  %i1, 0                                    
    return NULL;                                                      
                                                                      
  if ( !value )                                                       
40003b3c:	02 80 00 34 	be  40003c0c <rtems_bsp_cmdline_get_param+0xe0>
40003b40:	80 a6 a0 00 	cmp  %i2, 0                                    
    return NULL;                                                      
                                                                      
  if ( !length )                                                      
40003b44:	22 80 00 33 	be,a   40003c10 <rtems_bsp_cmdline_get_param+0xe4>
40003b48:	b2 10 20 00 	clr  %i1                                       
    return NULL;                                                      
                                                                      
  value[0] = '\0';                                                    
40003b4c:	c0 2e 40 00 	clrb  [ %i1 ]                                  
                                                                      
  p = rtems_bsp_cmdline_get_param_raw( name );                        
40003b50:	40 00 00 32 	call  40003c18 <rtems_bsp_cmdline_get_param_raw>
40003b54:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if ( !p )                                                           
40003b58:	80 a2 20 00 	cmp  %o0, 0                                    
40003b5c:	22 80 00 2d 	be,a   40003c10 <rtems_bsp_cmdline_get_param+0xe4>
40003b60:	b2 10 20 00 	clr  %i1                                       
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
40003b64:	c6 0a 00 00 	ldub  [ %o0 ], %g3                             
40003b68:	85 28 e0 18 	sll  %g3, 0x18, %g2                            
40003b6c:	80 a0 a0 00 	cmp  %g2, 0                                    
40003b70:	02 80 00 25 	be  40003c04 <rtems_bsp_cmdline_get_param+0xd8><== NEVER TAKEN
40003b74:	80 a6 a0 01 	cmp  %i2, 1                                    
40003b78:	02 80 00 23 	be  40003c04 <rtems_bsp_cmdline_get_param+0xd8><== NEVER TAKEN
40003b7c:	b4 06 bf ff 	add  %i2, -1, %i2                              
    value[i] = '\0';                                                  
  }                                                                   
                                                                      
}                                                                     
                                                                      
const char *rtems_bsp_cmdline_get_param(                              
40003b80:	82 10 20 00 	clr  %g1                                       
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
40003b84:	88 10 20 00 	clr  %g4                                       
    value[i] = '\0';                                                  
  }                                                                   
                                                                      
}                                                                     
                                                                      
const char *rtems_bsp_cmdline_get_param(                              
40003b88:	10 80 00 12 	b  40003bd0 <rtems_bsp_cmdline_get_param+0xa4> 
40003b8c:	ba 10 20 00 	clr  %i5                                       
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
    if ( *p == '\"' ) {                                               
      quotes++;                                                       
    } else if ( ((quotes % 2) == 0) && *p == ' ' )                    
40003b90:	32 80 00 06 	bne,a   40003ba8 <rtems_bsp_cmdline_get_param+0x7c>
40003b94:	c6 2e 40 04 	stb  %g3, [ %i1 + %g4 ]                        
40003b98:	80 a0 a0 20 	cmp  %g2, 0x20                                 
40003b9c:	02 80 00 1a 	be  40003c04 <rtems_bsp_cmdline_get_param+0xd8>
40003ba0:	01 00 00 00 	nop                                            
      break;                                                          
    value[i++] = *p++;                                                
40003ba4:	c6 2e 40 04 	stb  %g3, [ %i1 + %g4 ]                        
40003ba8:	82 00 60 01 	inc  %g1                                       
    value[i] = '\0';                                                  
40003bac:	c0 2e 40 01 	clrb  [ %i1 + %g1 ]                            
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
40003bb0:	c6 0a 00 01 	ldub  [ %o0 + %g1 ], %g3                       
40003bb4:	85 28 e0 18 	sll  %g3, 0x18, %g2                            
40003bb8:	80 a0 a0 00 	cmp  %g2, 0                                    
40003bbc:	02 80 00 12 	be  40003c04 <rtems_bsp_cmdline_get_param+0xd8>
40003bc0:	88 10 00 01 	mov  %g1, %g4                                  
40003bc4:	80 a0 40 1a 	cmp  %g1, %i2                                  
40003bc8:	02 80 00 0f 	be  40003c04 <rtems_bsp_cmdline_get_param+0xd8>
40003bcc:	01 00 00 00 	nop                                            
    if ( *p == '\"' ) {                                               
40003bd0:	85 38 a0 18 	sra  %g2, 0x18, %g2                            
40003bd4:	80 a0 a0 22 	cmp  %g2, 0x22                                 
40003bd8:	12 bf ff ee 	bne  40003b90 <rtems_bsp_cmdline_get_param+0x64>
40003bdc:	80 8f 60 01 	btst  1, %i5                                   
      quotes++;                                                       
    } else if ( ((quotes % 2) == 0) && *p == ' ' )                    
      break;                                                          
    value[i++] = *p++;                                                
40003be0:	c6 2e 40 04 	stb  %g3, [ %i1 + %g4 ]                        
40003be4:	82 00 60 01 	inc  %g1                                       
    value[i] = '\0';                                                  
40003be8:	c0 2e 40 01 	clrb  [ %i1 + %g1 ]                            
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
40003bec:	c6 0a 00 01 	ldub  [ %o0 + %g1 ], %g3                       
    if ( *p == '\"' ) {                                               
      quotes++;                                                       
40003bf0:	ba 07 60 01 	inc  %i5                                       
  int         i;                                                      
  int         quotes;                                                 
  const char *p = start;                                              
                                                                      
  quotes=0;                                                           
  for (i=0 ; *p && i<length-1; ) {                                    
40003bf4:	85 28 e0 18 	sll  %g3, 0x18, %g2                            
40003bf8:	80 a0 a0 00 	cmp  %g2, 0                                    
40003bfc:	12 bf ff f2 	bne  40003bc4 <rtems_bsp_cmdline_get_param+0x98><== ALWAYS TAKEN
40003c00:	88 10 00 01 	mov  %g1, %g4                                  
    return NULL;                                                      
                                                                      
  copy_string( p, value, length );                                    
                                                                      
  return value;                                                       
}                                                                     
40003c04:	81 c7 e0 08 	ret                                            
40003c08:	91 e8 00 19 	restore  %g0, %i1, %o0                         
)                                                                     
{                                                                     
  const char *p;                                                      
                                                                      
  if ( !name )                                                        
    return NULL;                                                      
40003c0c:	b2 10 20 00 	clr  %i1                                       
    return NULL;                                                      
                                                                      
  copy_string( p, value, length );                                    
                                                                      
  return value;                                                       
}                                                                     
40003c10:	81 c7 e0 08 	ret                                            
40003c14:	91 e8 00 19 	restore  %g0, %i1, %o0                         
                                                                      

40008f10 <rtems_chain_get_with_wait>: rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) {
40008f10:	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 );                                     
40008f14:	40 00 01 a1 	call  40009598 <_Chain_Get>                    
40008f18:	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(                                         
40008f1c:	92 10 20 00 	clr  %o1                                       
40008f20:	ba 10 00 08 	mov  %o0, %i5                                  
40008f24:	94 10 00 1a 	mov  %i2, %o2                                  
40008f28:	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                    
40008f2c:	80 a7 60 00 	cmp  %i5, 0                                    
40008f30:	12 80 00 0a 	bne  40008f58 <rtems_chain_get_with_wait+0x48> 
40008f34:	96 07 bf fc 	add  %fp, -4, %o3                              
  ) {                                                                 
    rtems_event_set out;                                              
    sc = rtems_event_receive(                                         
40008f38:	7f ff fc df 	call  400082b4 <rtems_event_receive>           
40008f3c:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  while (                                                             
40008f40:	80 a2 20 00 	cmp  %o0, 0                                    
40008f44:	02 bf ff f4 	be  40008f14 <rtems_chain_get_with_wait+0x4>   <== NEVER TAKEN
40008f48:	01 00 00 00 	nop                                            
      timeout,                                                        
      &out                                                            
    );                                                                
  }                                                                   
                                                                      
  *node_ptr = node;                                                   
40008f4c:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
                                                                      
  return sc;                                                          
}                                                                     
40008f50:	81 c7 e0 08 	ret                                            
40008f54:	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                    
40008f58:	90 10 20 00 	clr  %o0                                       
      timeout,                                                        
      &out                                                            
    );                                                                
  }                                                                   
                                                                      
  *node_ptr = node;                                                   
40008f5c:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
                                                                      
  return sc;                                                          
}                                                                     
40008f60:	81 c7 e0 08 	ret                                            
40008f64:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

400044e4 <rtems_cpu_usage_report_with_plugin>: */ void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) {
400044e4:	9d e3 bf 70 	save  %sp, -144, %sp                           
    uint32_t seconds, nanoseconds;                                    
  #else                                                               
    uint32_t           total_units = 0;                               
  #endif                                                              
                                                                      
  if ( !print )                                                       
400044e8:	80 a6 60 00 	cmp  %i1, 0                                    
400044ec:	02 80 00 85 	be  40004700 <rtems_cpu_usage_report_with_plugin+0x21c><== NEVER TAKEN
400044f0:	03 10 00 8d 	sethi  %hi(0x40023400), %g1                    
                                                                      
static inline void _Timestamp64_implementation_Set_to_zero(           
  Timestamp64_Control *_time                                          
)                                                                     
{                                                                     
  *_time = 0;                                                         
400044f4:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
400044f8:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
400044fc:	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;            
40004500:	f8 18 60 90 	ldd  [ %g1 + 0x90 ], %i4                       
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
40004504:	13 10 00 7f 	sethi  %hi(0x4001fc00), %o1                    
40004508:	2b 10 00 8b 	sethi  %hi(0x40022c00), %l5                    
4000450c:	92 12 62 08 	or  %o1, 0x208, %o1                            
40004510:	aa 15 62 48 	or  %l5, 0x248, %l5                            
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
                                                                      
        (*print)(                                                     
40004514:	25 10 00 7f 	sethi  %hi(0x4001fc00), %l2                    
 */                                                                   
static inline void _TOD_Get_uptime(                                   
  Timestamp_Control *time                                             
)                                                                     
{                                                                     
  _TOD_Get_with_nanoseconds( time, &_TOD.uptime );                    
40004518:	29 10 00 8b 	sethi  %hi(0x40022c00), %l4                    
        }                                                             
      }                                                               
    }                                                                 
  #endif                                                              
                                                                      
  (*print)(                                                           
4000451c:	9f c6 40 00 	call  %i1                                      
40004520:	27 10 00 7f 	sethi  %hi(0x4001fc00), %l3                    
#endif                                                                
                                                                      
/*                                                                    
 *  rtems_cpu_usage_report                                            
 */                                                                   
void rtems_cpu_usage_report_with_plugin(                              
40004524:	ac 05 60 0c 	add  %l5, 0xc, %l6                             
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
                                                                      
        (*print)(                                                     
40004528:	a4 14 a3 80 	or  %l2, 0x380, %l2                            
4000452c:	a8 15 22 30 	or  %l4, 0x230, %l4                            
           */                                                         
                                                                      
          seconds = _Timestamp_Get_seconds( &ran );                   
          nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /          
            TOD_NANOSECONDS_PER_MICROSECOND;                          
          (*print)( context,                                          
40004530:	a6 14 e3 98 	or  %l3, 0x398, %l3                            
    #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)             
      if ( !_Objects_Information_table[ api_index ] )                 
        continue;                                                     
    #endif                                                            
                                                                      
    information = _Objects_Information_table[ api_index ][ 1 ];       
40004534:	c2 05 40 00 	ld  [ %l5 ], %g1                               
40004538:	e2 00 60 04 	ld  [ %g1 + 4 ], %l1                           
    if ( information ) {                                              
4000453c:	80 a4 60 00 	cmp  %l1, 0                                    
40004540:	22 80 00 56 	be,a   40004698 <rtems_cpu_usage_report_with_plugin+0x1b4><== NEVER TAKEN
40004544:	aa 05 60 04 	add  %l5, 4, %l5                               <== NOT EXECUTED
      for ( i=1 ; i <= information->maximum ; i++ ) {                 
40004548:	c2 14 60 10 	lduh  [ %l1 + 0x10 ], %g1                      
4000454c:	86 90 60 00 	orcc  %g1, 0, %g3                              
40004550:	02 80 00 51 	be  40004694 <rtems_cpu_usage_report_with_plugin+0x1b0>
40004554:	a0 10 20 01 	mov  1, %l0                                    
        the_thread = (Thread_Control *)information->local_table[ i ]; 
40004558:	10 80 00 2d 	b  4000460c <rtems_cpu_usage_report_with_plugin+0x128>
4000455c:	c4 04 60 1c 	ld  [ %l1 + 0x1c ], %g2                        
40004560:	90 07 bf d8 	add  %fp, -40, %o0                             
40004564:	40 00 19 d2 	call  4000acac <_TOD_Get_with_nanoseconds>     
40004568:	92 10 00 14 	mov  %l4, %o1                                  
4000456c:	c4 1f bf d8 	ldd  [ %fp + -40 ], %g2                        
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
40004570:	86 a0 c0 1d 	subcc  %g3, %i5, %g3                           
40004574:	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 );            
40004578:	90 07 bf e8 	add  %fp, -24, %o0                             
4000457c:	c4 3f bf e0 	std  %g2, [ %fp + -32 ]                        
40004580:	92 07 bf e0 	add  %fp, -32, %o1                             
40004584:	94 07 bf d0 	add  %fp, -48, %o2                             
40004588:	40 00 23 aa 	call  4000d430 <_Timestamp64_Divide>           
4000458c:	96 07 bf d4 	add  %fp, -44, %o3                             
                                                                      
          /*                                                          
           * Print the information                                    
           */                                                         
                                                                      
          seconds = _Timestamp_Get_seconds( &ran );                   
40004590:	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);                           
40004594:	94 10 20 00 	clr  %o2                                       
40004598:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
4000459c:	90 10 00 1a 	mov  %i2, %o0                                  
400045a0:	96 12 e2 00 	or  %o3, 0x200, %o3                            
400045a4:	40 00 5e f7 	call  4001c180 <__divdi3>                      
400045a8:	92 10 00 1b 	mov  %i3, %o1                                  
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
400045ac:	94 10 20 00 	clr  %o2                                       
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_seconds(       
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time / 1000000000L);                           
400045b0:	ae 10 00 09 	mov  %o1, %l7                                  
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
400045b4:	90 10 00 1a 	mov  %i2, %o0                                  
400045b8:	92 10 00 1b 	mov  %i3, %o1                                  
400045bc:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400045c0:	40 00 5f db 	call  4001c52c <__moddi3>                      
400045c4:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
          nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /          
400045c8:	90 10 00 09 	mov  %o1, %o0                                  
400045cc:	40 00 5d 95 	call  4001bc20 <.udiv>                         
400045d0:	92 10 23 e8 	mov  0x3e8, %o1                                
            TOD_NANOSECONDS_PER_MICROSECOND;                          
          (*print)( context,                                          
400045d4:	d8 1f bf d0 	ldd  [ %fp + -48 ], %o4                        
          /*                                                          
           * Print the information                                    
           */                                                         
                                                                      
          seconds = _Timestamp_Get_seconds( &ran );                   
          nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /          
400045d8:	96 10 00 08 	mov  %o0, %o3                                  
            TOD_NANOSECONDS_PER_MICROSECOND;                          
          (*print)( context,                                          
400045dc:	92 10 00 13 	mov  %l3, %o1                                  
400045e0:	90 10 00 18 	mov  %i0, %o0                                  
400045e4:	9f c6 40 00 	call  %i1                                      
400045e8:	94 10 00 17 	mov  %l7, %o2                                  
400045ec:	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++ ) {                 
400045f0:	a0 04 20 01 	inc  %l0                                       
400045f4:	83 28 e0 10 	sll  %g3, 0x10, %g1                            
400045f8:	83 30 60 10 	srl  %g1, 0x10, %g1                            
400045fc:	80 a0 40 10 	cmp  %g1, %l0                                  
40004600:	2a 80 00 26 	bcs,a   40004698 <rtems_cpu_usage_report_with_plugin+0x1b4>
40004604:	aa 05 60 04 	add  %l5, 4, %l5                               
        the_thread = (Thread_Control *)information->local_table[ i ]; 
40004608:	c4 04 60 1c 	ld  [ %l1 + 0x1c ], %g2                        
4000460c:	83 2c 20 02 	sll  %l0, 2, %g1                               
40004610:	f6 00 80 01 	ld  [ %g2 + %g1 ], %i3                         
                                                                      
        if ( !the_thread )                                            
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40004614:	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 )                                            
40004618:	80 a6 e0 00 	cmp  %i3, 0                                    
4000461c:	02 bf ff f5 	be  400045f0 <rtems_cpu_usage_report_with_plugin+0x10c><== NEVER TAKEN
40004620:	92 10 20 0d 	mov  0xd, %o1                                  
          continue;                                                   
                                                                      
        rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40004624:	40 00 14 35 	call  400096f8 <rtems_object_get_name>         
40004628:	d0 06 e0 08 	ld  [ %i3 + 8 ], %o0                           
                                                                      
        (*print)(                                                     
4000462c:	d4 06 e0 08 	ld  [ %i3 + 8 ], %o2                           
40004630:	90 10 00 18 	mov  %i0, %o0                                  
40004634:	92 10 00 12 	mov  %l2, %o1                                  
40004638:	9f c6 40 00 	call  %i1                                      
4000463c:	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 ) {  
40004640:	03 10 00 8d 	sethi  %hi(0x40023400), %g1                    
40004644:	82 10 60 30 	or  %g1, 0x30, %g1	! 40023430 <_Per_CPU_Information>
40004648:	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;                            
4000464c:	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 ) {  
40004650:	f4 01 20 08 	ld  [ %g4 + 8 ], %i2                           
40004654:	c8 06 e0 08 	ld  [ %i3 + 8 ], %g4                           
40004658:	80 a6 80 04 	cmp  %i2, %g4                                  
4000465c:	12 bf ff c1 	bne  40004560 <rtems_cpu_usage_report_with_plugin+0x7c>
40004660:	c4 3f bf e8 	std  %g2, [ %fp + -24 ]                        
        *time_of_context_switch = _Thread_Time_of_last_context_switch;
40004664:	f4 18 60 20 	ldd  [ %g1 + 0x20 ], %i2                       
40004668:	92 10 00 14 	mov  %l4, %o1                                  
4000466c:	40 00 19 90 	call  4000acac <_TOD_Get_with_nanoseconds>     
40004670:	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 );             
40004674:	c4 1f bf d8 	ldd  [ %fp + -40 ], %g2                        
  const Timestamp64_Control *_start,                                  
  const Timestamp64_Control *_end,                                    
  Timestamp64_Control       *_result                                  
)                                                                     
{                                                                     
  *_result = *_end - *_start;                                         
40004678:	96 a0 c0 1b 	subcc  %g3, %i3, %o3                           
4000467c:	94 60 80 1a 	subx  %g2, %i2, %o2                            
static inline void _Timestamp64_implementation_Add_to(                
  Timestamp64_Control       *_time,                                   
  const Timestamp64_Control *_add                                     
)                                                                     
{                                                                     
  *_time += *_add;                                                    
40004680:	f4 1f bf e8 	ldd  [ %fp + -24 ], %i2                        
40004684:	9a 86 c0 0b 	addcc  %i3, %o3, %o5                           
40004688:	98 46 80 0a 	addx  %i2, %o2, %o4                            
4000468c:	10 bf ff b9 	b  40004570 <rtems_cpu_usage_report_with_plugin+0x8c>
40004690:	d8 3f bf e8 	std  %o4, [ %fp + -24 ]                        
40004694:	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++ ) {
40004698:	80 a5 40 16 	cmp  %l5, %l6                                  
4000469c:	32 bf ff a7 	bne,a   40004538 <rtems_cpu_usage_report_with_plugin+0x54>
400046a0:	c2 05 40 00 	ld  [ %l5 ], %g1                               
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    seconds = _Timestamp_Get_seconds( &total );                       
400046a4:	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);                           
400046a8:	94 10 20 00 	clr  %o2                                       
400046ac:	90 10 00 1c 	mov  %i4, %o0                                  
400046b0:	92 10 00 1d 	mov  %i5, %o1                                  
400046b4:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400046b8:	40 00 5e b2 	call  4001c180 <__divdi3>                      
400046bc:	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);                           
400046c0:	94 10 20 00 	clr  %o2                                       
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_seconds(       
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time / 1000000000L);                           
400046c4:	b6 10 00 09 	mov  %o1, %i3                                  
                                                                      
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(   
  const Timestamp64_Control *_time                                    
)                                                                     
{                                                                     
  return (uint32_t) (*_time % 1000000000L);                           
400046c8:	90 10 00 1c 	mov  %i4, %o0                                  
400046cc:	92 10 00 1d 	mov  %i5, %o1                                  
400046d0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400046d4:	40 00 5f 96 	call  4001c52c <__moddi3>                      
400046d8:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
    nanoseconds = _Timestamp_Get_nanoseconds( &total ) /              
400046dc:	90 10 00 09 	mov  %o1, %o0                                  
400046e0:	40 00 5d 50 	call  4001bc20 <.udiv>                         
400046e4:	92 10 23 e8 	mov  0x3e8, %o1                                
      TOD_NANOSECONDS_PER_MICROSECOND;                                
    (*print)(                                                         
400046e8:	94 10 00 1b 	mov  %i3, %o2                                  
    }                                                                 
  }                                                                   
                                                                      
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    seconds = _Timestamp_Get_seconds( &total );                       
    nanoseconds = _Timestamp_Get_nanoseconds( &total ) /              
400046ec:	96 10 00 08 	mov  %o0, %o3                                  
      TOD_NANOSECONDS_PER_MICROSECOND;                                
    (*print)(                                                         
400046f0:	13 10 00 7f 	sethi  %hi(0x4001fc00), %o1                    
400046f4:	90 10 00 18 	mov  %i0, %o0                                  
400046f8:	9f c6 40 00 	call  %i1                                      
400046fc:	92 12 63 b0 	or  %o1, 0x3b0, %o1                            
40004700:	81 c7 e0 08 	ret                                            
40004704:	81 e8 00 00 	restore                                        
                                                                      

40010854 <rtems_deviceio_errno>: [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) {
40010854:	9d e3 bf a0 	save  %sp, -96, %sp                            
40010858:	82 10 00 18 	mov  %i0, %g1                                  
  if (sc == RTEMS_SUCCESSFUL) {                                       
4001085c:	80 a0 60 00 	cmp  %g1, 0                                    
40010860:	02 80 00 0c 	be  40010890 <rtems_deviceio_errno+0x3c>       
40010864:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
  } else {                                                            
    int eno = EINVAL;                                                 
                                                                      
    if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {                   
40010868:	80 a0 60 1c 	cmp  %g1, 0x1c                                 
4001086c:	18 80 00 06 	bgu  40010884 <rtems_deviceio_errno+0x30>      <== NEVER TAKEN
40010870:	ba 10 20 16 	mov  0x16, %i5                                 
      eno = status_code_to_errno [sc];                                
40010874:	83 28 60 02 	sll  %g1, 2, %g1                               
40010878:	05 10 00 79 	sethi  %hi(0x4001e400), %g2                    
4001087c:	84 10 a3 ac 	or  %g2, 0x3ac, %g2	! 4001e7ac <status_code_to_errno>
40010880:	fa 00 80 01 	ld  [ %g2 + %g1 ], %i5                         
    }                                                                 
                                                                      
    errno = eno;                                                      
40010884:	40 00 00 2f 	call  40010940 <__errno>                       
40010888:	b0 10 3f ff 	mov  -1, %i0                                   
4001088c:	fa 22 00 00 	st  %i5, [ %o0 ]                               
                                                                      
    return -1;                                                        
  }                                                                   
}                                                                     
40010890:	81 c7 e0 08 	ret                                            
40010894:	81 e8 00 00 	restore                                        
                                                                      

40004610 <rtems_disk_create_log>: dev_t phys, rtems_blkdev_bnum block_begin, rtems_blkdev_bnum block_count, const char *name ) {
40004610:	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;                                       
40004614:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  char *alloc_name = NULL;                                            
                                                                      
  sc = disk_lock();                                                   
40004618:	7f ff fe f5 	call  400041ec <disk_lock>                     
4000461c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004620:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40004624:	02 80 00 04 	be  40004634 <rtems_disk_create_log+0x24>      <== ALWAYS TAKEN
40004628:	92 10 00 1b 	mov  %i3, %o1                                  
  }                                                                   
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000462c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004630:	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);                               
40004634:	90 10 00 1a 	mov  %i2, %o0                                  
40004638:	7f ff fe b0 	call  400040f8 <get_disk_entry>                
4000463c:	94 10 20 01 	mov  1, %o2                                    
  if (phys_dd == NULL) {                                              
40004640:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40004644:	02 80 00 25 	be  400046d8 <rtems_disk_create_log+0xc8>      
40004648:	d4 07 a0 5c 	ld  [ %fp + 0x5c ], %o2                        
    disk_unlock();                                                    
                                                                      
    return RTEMS_INVALID_ID;                                          
  }                                                                   
                                                                      
  sc = create_disk(dev, name, &dd, &alloc_name);                      
4000464c:	90 10 00 18 	mov  %i0, %o0                                  
40004650:	92 10 00 19 	mov  %i1, %o1                                  
40004654:	96 07 bf f8 	add  %fp, -8, %o3                              
40004658:	7f ff ff 03 	call  40004264 <create_disk>                   
4000465c:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004660:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40004664:	12 80 00 19 	bne  400046c8 <rtems_disk_create_log+0xb8>     
40004668:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  sc = rtems_disk_init_log(                                           
4000466c:	92 10 00 1b 	mov  %i3, %o1                                  
40004670:	94 10 00 1c 	mov  %i4, %o2                                  
40004674:	40 00 31 91 	call  40010cb8 <rtems_disk_init_log>           
40004678:	96 10 00 1d 	mov  %i5, %o3                                  
    phys_dd,                                                          
    block_begin,                                                      
    block_count                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
4000467c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  dd->name = alloc_name;                                              
                                                                      
  ++phys_dd->uses;                                                    
40004680:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        
    block_begin,                                                      
    block_count                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
40004684:	c6 07 bf fc 	ld  [ %fp + -4 ], %g3                          
                                                                      
  ++phys_dd->uses;                                                    
40004688:	84 00 a0 01 	inc  %g2                                       
    phys_dd,                                                          
    block_begin,                                                      
    block_count                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
4000468c:	f0 38 40 00 	std  %i0, [ %g1 ]                              
  dd->name = alloc_name;                                              
40004690:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
                                                                      
  ++phys_dd->uses;                                                    
40004694:	c4 26 e0 14 	st  %g2, [ %i3 + 0x14 ]                        
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004698:	80 a2 20 00 	cmp  %o0, 0                                    
4000469c:	02 80 00 0b 	be  400046c8 <rtems_disk_create_log+0xb8>      
400046a0:	a0 10 00 08 	mov  %o0, %l0                                  
    dd->ioctl = null_handler;                                         
400046a4:	05 10 00 10 	sethi  %hi(0x40004000), %g2                    
400046a8:	84 10 a1 8c 	or  %g2, 0x18c, %g2	! 4000418c <null_handler>  
    rtems_disk_delete(dev);                                           
400046ac:	92 10 00 19 	mov  %i1, %o1                                  
  dd->name = alloc_name;                                              
                                                                      
  ++phys_dd->uses;                                                    
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    dd->ioctl = null_handler;                                         
400046b0:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
    rtems_disk_delete(dev);                                           
400046b4:	7f ff ff 5c 	call  40004424 <rtems_disk_delete>             
400046b8:	90 10 00 18 	mov  %i0, %o0                                  
    disk_unlock();                                                    
400046bc:	7f ff fe db 	call  40004228 <disk_unlock>                   
400046c0:	b0 10 00 10 	mov  %l0, %i0                                  
400046c4:	30 80 00 03 	b,a   400046d0 <rtems_disk_create_log+0xc0>    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  disk_unlock();                                                      
400046c8:	7f ff fe d8 	call  40004228 <disk_unlock>                   
400046cc:	b0 10 00 10 	mov  %l0, %i0                                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400046d0:	81 c7 e0 08 	ret                                            
400046d4:	81 e8 00 00 	restore                                        
    return sc;                                                        
  }                                                                   
                                                                      
  phys_dd = get_disk_entry(phys, true);                               
  if (phys_dd == NULL) {                                              
    disk_unlock();                                                    
400046d8:	7f ff fe d4 	call  40004228 <disk_unlock>                   
400046dc:	a0 10 20 04 	mov  4, %l0                                    
  }                                                                   
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400046e0:	81 c7 e0 08 	ret                                            
400046e4:	91 e8 00 10 	restore  %g0, %l0, %o0                         
                                                                      

400046e8 <rtems_disk_create_phys>: rtems_blkdev_bnum block_count, rtems_block_device_ioctl handler, void *driver_data, const char *name ) {
400046e8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_disk_device *dd = NULL;                                       
400046ec:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  char *alloc_name = NULL;                                            
400046f0:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
  if (handler == NULL) {                                              
400046f4:	80 a7 20 00 	cmp  %i4, 0                                    
400046f8:	02 80 00 07 	be  40004714 <rtems_disk_create_phys+0x2c>     
400046fc:	a0 10 20 09 	mov  9, %l0                                    
    return RTEMS_INVALID_ADDRESS;                                     
  }                                                                   
                                                                      
  sc = disk_lock();                                                   
40004700:	7f ff fe bb 	call  400041ec <disk_lock>                     
40004704:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004708:	a0 92 20 00 	orcc  %o0, 0, %l0                              
4000470c:	02 80 00 04 	be  4000471c <rtems_disk_create_phys+0x34>     <== ALWAYS TAKEN
40004710:	d4 07 a0 5c 	ld  [ %fp + 0x5c ], %o2                        
  }                                                                   
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40004714:	81 c7 e0 08 	ret                                            
40004718:	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);                      
4000471c:	90 10 00 18 	mov  %i0, %o0                                  
40004720:	92 10 00 19 	mov  %i1, %o1                                  
40004724:	96 07 bf f8 	add  %fp, -8, %o3                              
40004728:	7f ff fe cf 	call  40004264 <create_disk>                   
4000472c:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004730:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40004734:	12 80 00 0e 	bne  4000476c <rtems_disk_create_phys+0x84>    
40004738:	d0 07 bf f8 	ld  [ %fp + -8 ], %o0                          
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  sc = rtems_disk_init_phys(                                          
4000473c:	92 10 00 1a 	mov  %i2, %o1                                  
40004740:	94 10 00 1b 	mov  %i3, %o2                                  
40004744:	96 10 00 1c 	mov  %i4, %o3                                  
40004748:	40 00 31 42 	call  40010c50 <rtems_disk_init_phys>          
4000474c:	98 10 00 1d 	mov  %i5, %o4                                  
    block_count,                                                      
    handler,                                                          
    driver_data                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
40004750:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  dd->name = alloc_name;                                              
40004754:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    block_count,                                                      
    handler,                                                          
    driver_data                                                       
  );                                                                  
                                                                      
  dd->dev = dev;                                                      
40004758:	f0 38 40 00 	std  %i0, [ %g1 ]                              
  dd->name = alloc_name;                                              
4000475c:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004760:	80 a2 20 00 	cmp  %o0, 0                                    
40004764:	12 80 00 06 	bne  4000477c <rtems_disk_create_phys+0x94>    
40004768:	a0 10 00 08 	mov  %o0, %l0                                  
    disk_unlock();                                                    
                                                                      
    return sc;                                                        
  }                                                                   
                                                                      
  disk_unlock();                                                      
4000476c:	7f ff fe af 	call  40004228 <disk_unlock>                   
40004770:	b0 10 00 10 	mov  %l0, %i0                                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40004774:	81 c7 e0 08 	ret                                            
40004778:	81 e8 00 00 	restore                                        
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    dd->ioctl = null_handler;                                         
4000477c:	05 10 00 10 	sethi  %hi(0x40004000), %g2                    
40004780:	84 10 a1 8c 	or  %g2, 0x18c, %g2	! 4000418c <null_handler>  
    rtems_disk_delete(dev);                                           
40004784:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  dd->dev = dev;                                                      
  dd->name = alloc_name;                                              
                                                                      
  if (sc != RTEMS_SUCCESSFUL) {                                       
    dd->ioctl = null_handler;                                         
40004788:	c4 20 60 38 	st  %g2, [ %g1 + 0x38 ]                        
    rtems_disk_delete(dev);                                           
4000478c:	7f ff ff 26 	call  40004424 <rtems_disk_delete>             
40004790:	90 10 00 18 	mov  %i0, %o0                                  
    disk_unlock();                                                    
40004794:	7f ff fe a5 	call  40004228 <disk_unlock>                   
40004798:	b0 10 00 10 	mov  %l0, %i0                                  
4000479c:	30 bf ff f6 	b,a   40004774 <rtems_disk_create_phys+0x8c>   
                                                                      

40004424 <rtems_disk_delete>: } } rtems_status_code rtems_disk_delete(dev_t dev) {
40004424:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_disk_device *dd = NULL;                                       
                                                                      
  sc = disk_lock();                                                   
40004428:	7f ff ff 71 	call  400041ec <disk_lock>                     
4000442c:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004430:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40004434:	02 80 00 04 	be  40004444 <rtems_disk_delete+0x20>          <== ALWAYS TAKEN
40004438:	90 10 00 18 	mov  %i0, %o0                                  
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000443c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40004440:	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);                                     
40004444:	92 10 00 19 	mov  %i1, %o1                                  
40004448:	7f ff ff 2c 	call  400040f8 <get_disk_entry>                
4000444c:	94 10 20 01 	mov  1, %o2                                    
  if (dd == NULL) {                                                   
40004450:	82 92 20 00 	orcc  %o0, 0, %g1                              
40004454:	02 80 00 5e 	be  400045cc <rtems_disk_delete+0x1a8>         <== NEVER TAKEN
40004458:	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;  
4000445c:	e2 00 60 08 	ld  [ %g1 + 8 ], %l1                           
    disk_unlock();                                                    
                                                                      
    return RTEMS_INVALID_ID;                                          
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
40004460:	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) {                                       
40004464:	c4 0c 60 40 	ldub  [ %l1 + 0x40 ], %g2                      
40004468:	80 a0 a0 00 	cmp  %g2, 0                                    
4000446c:	22 80 00 43 	be,a   40004578 <rtems_disk_delete+0x154>      
40004470:	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) {                  
40004474:	2b 10 00 71 	sethi  %hi(0x4001c400), %l5                    
40004478:	c2 05 60 70 	ld  [ %l5 + 0x70 ], %g1	! 4001c470 <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;                                   
4000447c:	f2 04 40 00 	ld  [ %l1 ], %i1                               
40004480:	e4 04 60 04 	ld  [ %l1 + 4 ], %l2                           
    unsigned deleted_count = 0;                                       
                                                                      
    for (major = 0; major < disktab_size; ++major) {                  
40004484:	80 a0 60 00 	cmp  %g1, 0                                    
40004488:	02 80 00 33 	be  40004554 <rtems_disk_delete+0x130>         <== NEVER TAKEN
4000448c:	a8 10 20 00 	clr  %l4                                       
40004490:	2d 10 00 71 	sethi  %hi(0x4001c400), %l6                    
40004494:	b0 10 20 00 	clr  %i0                                       
40004498:	ac 15 a0 74 	or  %l6, 0x74, %l6                             
4000449c:	aa 15 60 70 	or  %l5, 0x70, %l5                             
          if (dd->uses == 0) {                                        
            ++deleted_count;                                          
            dtab->minor [minor] = NULL;                               
            free_disk_device(dd);                                     
          } else {                                                    
            dd->deleted = true;                                       
400044a0:	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;                
400044a4:	f6 05 80 00 	ld  [ %l6 ], %i3                               
    }                                                                 
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_disk_delete(dev_t dev)                                          
400044a8:	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;                
400044ac:	b6 06 c0 01 	add  %i3, %g1, %i3                             
                                                                      
      for (minor = 0; minor < dtab->size; ++minor) {                  
400044b0:	f4 06 e0 04 	ld  [ %i3 + 4 ], %i2                           
400044b4:	80 a6 a0 00 	cmp  %i2, 0                                    
400044b8:	22 80 00 23 	be,a   40004544 <rtems_disk_delete+0x120>      
400044bc:	c2 05 40 00 	ld  [ %l5 ], %g1                               
400044c0:	10 80 00 06 	b  400044d8 <rtems_disk_delete+0xb4>           
400044c4:	ba 10 20 00 	clr  %i5                                       
400044c8:	ba 07 60 01 	inc  %i5                                       
400044cc:	80 a7 40 1a 	cmp  %i5, %i2                                  
400044d0:	3a 80 00 1d 	bcc,a   40004544 <rtems_disk_delete+0x120>     
400044d4:	c2 05 40 00 	ld  [ %l5 ], %g1                               
        rtems_disk_device *dd = dtab->minor [minor];                  
400044d8:	c6 06 c0 00 	ld  [ %i3 ], %g3                               
    }                                                                 
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_disk_delete(dev_t dev)                                          
400044dc:	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];                  
400044e0:	d0 00 c0 02 	ld  [ %g3 + %g2 ], %o0                         
                                                                      
        if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
400044e4:	80 a2 20 00 	cmp  %o0, 0                                    
400044e8:	22 bf ff f9 	be,a   400044cc <rtems_disk_delete+0xa8>       
400044ec:	ba 07 60 01 	inc  %i5                                       
400044f0:	c8 02 20 08 	ld  [ %o0 + 8 ], %g4                           
400044f4:	f8 01 00 00 	ld  [ %g4 ], %i4                               
400044f8:	80 a7 00 19 	cmp  %i4, %i1                                  
400044fc:	32 bf ff f4 	bne,a   400044cc <rtems_disk_delete+0xa8>      <== NEVER TAKEN
40004500:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40004504:	c8 01 20 04 	ld  [ %g4 + 4 ], %g4                           
40004508:	80 a1 00 12 	cmp  %g4, %l2                                  
4000450c:	32 bf ff f0 	bne,a   400044cc <rtems_disk_delete+0xa8>      <== NEVER TAKEN
40004510:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40004514:	80 a4 40 08 	cmp  %l1, %o0                                  
40004518:	22 bf ff ed 	be,a   400044cc <rtems_disk_delete+0xa8>       
4000451c:	ba 07 60 01 	inc  %i5                                       
          if (dd->uses == 0) {                                        
40004520:	c8 02 20 14 	ld  [ %o0 + 0x14 ], %g4                        
40004524:	80 a1 20 00 	cmp  %g4, 0                                    
40004528:	22 80 00 25 	be,a   400045bc <rtems_disk_delete+0x198>      
4000452c:	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) {                  
40004530:	ba 07 60 01 	inc  %i5                                       
40004534:	80 a7 40 1a 	cmp  %i5, %i2                                  
40004538:	0a bf ff e8 	bcs  400044d8 <rtems_disk_delete+0xb4>         <== ALWAYS TAKEN
4000453c:	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) {                  
40004540:	c2 05 40 00 	ld  [ %l5 ], %g1                               <== NOT EXECUTED
40004544:	b0 06 20 01 	inc  %i0                                       
40004548:	80 a6 00 01 	cmp  %i0, %g1                                  
4000454c:	2a bf ff d7 	bcs,a   400044a8 <rtems_disk_delete+0x84>      
40004550:	f6 05 80 00 	ld  [ %l6 ], %i3                               
          }                                                           
        }                                                             
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
40004554:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        
40004558:	a8 20 40 14 	sub  %g1, %l4, %l4                             
    if (physical_disk->uses == 0) {                                   
4000455c:	80 a5 20 00 	cmp  %l4, 0                                    
40004560:	02 80 00 1f 	be  400045dc <rtems_disk_delete+0x1b8>         
40004564:	e8 24 60 14 	st  %l4, [ %l1 + 0x14 ]                        
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
40004568:	7f ff ff 30 	call  40004228 <disk_unlock>                   
4000456c:	b0 10 00 10 	mov  %l0, %i0                                  
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40004570:	81 c7 e0 08 	ret                                            
40004574:	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) {                                  
40004578:	80 a0 a0 00 	cmp  %g2, 0                                    
4000457c:	12 bf ff fb 	bne  40004568 <rtems_disk_delete+0x144>        <== NEVER TAKEN
40004580:	07 10 00 71 	sethi  %hi(0x4001c400), %g3                    
      --physical_disk->uses;                                          
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
40004584:	c4 00 40 00 	ld  [ %g1 ], %g2                               
      disktab [major].minor [minor] = NULL;                           
40004588:	c8 00 e0 74 	ld  [ %g3 + 0x74 ], %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);
4000458c:	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;                                          
40004590:	c6 04 60 14 	ld  [ %l1 + 0x14 ], %g3                        
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
      disktab [major].minor [minor] = NULL;                           
40004594:	85 28 a0 03 	sll  %g2, 3, %g2                               
40004598:	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;                                          
4000459c:	86 00 ff ff 	add  %g3, -1, %g3                              
      rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
      disktab [major].minor [minor] = NULL;                           
400045a0:	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;                                          
400045a4:	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);                               
400045a8:	7f ff fe fb 	call  40004194 <free_disk_device>              
400045ac:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
400045b0:	7f ff ff 1e 	call  40004228 <disk_unlock>                   
400045b4:	b0 10 00 10 	mov  %l0, %i0                                  
400045b8:	30 bf ff ee 	b,a   40004570 <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);                                     
400045bc:	7f ff fe f6 	call  40004194 <free_disk_device>              
400045c0:	a8 05 20 01 	inc  %l4                                       
400045c4:	10 bf ff c1 	b  400044c8 <rtems_disk_delete+0xa4>           
400045c8:	f4 06 e0 04 	ld  [ %i3 + 4 ], %i2                           
    return sc;                                                        
  }                                                                   
                                                                      
  dd = get_disk_entry(dev, true);                                     
  if (dd == NULL) {                                                   
    disk_unlock();                                                    
400045cc:	7f ff ff 17 	call  40004228 <disk_unlock>                   <== NOT EXECUTED
400045d0:	a0 10 20 04 	mov  4, %l0                                    <== NOT EXECUTED
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400045d4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400045d8:	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); 
400045dc:	c4 04 40 00 	ld  [ %l1 ], %g2                               
      disktab [major].minor [minor] = NULL;                           
400045e0:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
400045e4:	c6 00 60 74 	ld  [ %g1 + 0x74 ], %g3	! 4001c474 <disktab>   
      }                                                               
    }                                                                 
                                                                      
    physical_disk->uses -= deleted_count;                             
    if (physical_disk->uses == 0) {                                   
      rtems_filesystem_split_dev_t(physical_disk->dev, major, minor); 
400045e8:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
      disktab [major].minor [minor] = NULL;                           
400045ec:	85 28 a0 03 	sll  %g2, 3, %g2                               
400045f0:	c4 00 c0 02 	ld  [ %g3 + %g2 ], %g2                         
400045f4:	83 28 60 02 	sll  %g1, 2, %g1                               
      free_disk_device(physical_disk);                                
400045f8:	90 10 00 11 	mov  %l1, %o0                                  
400045fc:	7f ff fe e6 	call  40004194 <free_disk_device>              
40004600:	c0 20 80 01 	clr  [ %g2 + %g1 ]                             
  }                                                                   
                                                                      
  dd->deleted = true;                                                 
  rtems_disk_cleanup(dd);                                             
                                                                      
  disk_unlock();                                                      
40004604:	7f ff ff 09 	call  40004228 <disk_unlock>                   
40004608:	b0 10 00 10 	mov  %l0, %i0                                  
4000460c:	30 bf ff d9 	b,a   40004570 <rtems_disk_delete+0x14c>       
                                                                      

40004a14 <rtems_disk_io_done>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_disk_io_done(void) {
40004a14:	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) {                    
40004a18:	21 10 00 71 	sethi  %hi(0x4001c400), %l0                    
40004a1c:	c2 04 20 70 	ld  [ %l0 + 0x70 ], %g1	! 4001c470 <disktab_size>
40004a20:	35 10 00 71 	sethi  %hi(0x4001c400), %i2                    
40004a24:	b6 10 20 00 	clr  %i3                                       
40004a28:	fa 06 a0 74 	ld  [ %i2 + 0x74 ], %i5                        
40004a2c:	80 a0 60 00 	cmp  %g1, 0                                    
40004a30:	02 80 00 1d 	be  40004aa4 <rtems_disk_io_done+0x90>         <== NEVER TAKEN
40004a34:	b2 14 20 70 	or  %l0, 0x70, %i1                             
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_disk_io_done(void)                                              
40004a38:	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;                  
40004a3c:	b8 07 40 01 	add  %i5, %g1, %i4                             
                                                                      
    for (minor = 0; minor < dtab->size; ++minor) {                    
40004a40:	c4 07 20 04 	ld  [ %i4 + 4 ], %g2                           
40004a44:	80 a0 a0 00 	cmp  %g2, 0                                    
40004a48:	02 80 00 10 	be  40004a88 <rtems_disk_io_done+0x74>         
40004a4c:	c6 07 40 01 	ld  [ %i5 + %g1 ], %g3                         
40004a50:	ba 10 20 00 	clr  %i5                                       
      rtems_disk_device *dd = dtab->minor [minor];                    
40004a54:	83 2f 60 02 	sll  %i5, 2, %g1                               
40004a58:	c2 00 c0 01 	ld  [ %g3 + %g1 ], %g1                         
                                                                      
      if (dd != NULL) {                                               
40004a5c:	90 90 60 00 	orcc  %g1, 0, %o0                              
40004a60:	02 80 00 06 	be  40004a78 <rtems_disk_io_done+0x64>         
40004a64:	ba 07 60 01 	inc  %i5                                       
        free_disk_device(dd);                                         
40004a68:	7f ff fd cb 	call  40004194 <free_disk_device>              
40004a6c:	01 00 00 00 	nop                                            
40004a70:	c4 07 20 04 	ld  [ %i4 + 4 ], %g2                           
40004a74:	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) {                    
40004a78:	80 a0 80 1d 	cmp  %g2, %i5                                  
40004a7c:	18 bf ff f7 	bgu  40004a58 <rtems_disk_io_done+0x44>        
40004a80:	83 2f 60 02 	sll  %i5, 2, %g1                               
40004a84:	fa 06 a0 74 	ld  [ %i2 + 0x74 ], %i5                        
                                                                      
      if (dd != NULL) {                                               
        free_disk_device(dd);                                         
      }                                                               
    }                                                                 
    free(dtab->minor);                                                
40004a88:	40 00 02 31 	call  4000534c <free>                          
40004a8c:	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) {                    
40004a90:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40004a94:	b6 06 e0 01 	inc  %i3                                       
40004a98:	80 a0 40 1b 	cmp  %g1, %i3                                  
40004a9c:	18 bf ff e8 	bgu  40004a3c <rtems_disk_io_done+0x28>        
40004aa0:	83 2e e0 03 	sll  %i3, 3, %g1                               
        free_disk_device(dd);                                         
      }                                                               
    }                                                                 
    free(dtab->minor);                                                
  }                                                                   
  free(disktab);                                                      
40004aa4:	40 00 02 2a 	call  4000534c <free>                          
40004aa8:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  rtems_semaphore_delete(diskdevs_mutex);                             
40004aac:	3b 10 00 71 	sethi  %hi(0x4001c400), %i5                    
40004ab0:	d0 07 60 6c 	ld  [ %i5 + 0x6c ], %o0	! 4001c46c <diskdevs_mutex>
40004ab4:	40 00 13 94 	call  40009904 <rtems_semaphore_delete>        
40004ab8:	b0 10 20 00 	clr  %i0                                       
                                                                      
  diskdevs_mutex = RTEMS_ID_NONE;                                     
40004abc:	c0 27 60 6c 	clr  [ %i5 + 0x6c ]                            
  disktab = NULL;                                                     
40004ac0:	c0 26 a0 74 	clr  [ %i2 + 0x74 ]                            
  disktab_size = 0;                                                   
40004ac4:	c0 24 20 70 	clr  [ %l0 + 0x70 ]                            
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40004ac8:	81 c7 e0 08 	ret                                            
40004acc:	81 e8 00 00 	restore                                        
                                                                      

40004968 <rtems_disk_io_initialize>: } } rtems_status_code rtems_disk_io_initialize(void) {
40004968:	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) {                                             
4000496c:	3b 10 00 71 	sethi  %hi(0x4001c400), %i5                    
40004970:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1	! 4001c470 <disktab_size>
40004974:	80 a0 60 00 	cmp  %g1, 0                                    
40004978:	12 80 00 19 	bne  400049dc <rtems_disk_io_initialize+0x74>  
4000497c:	b0 10 20 00 	clr  %i0                                       
    return RTEMS_SUCCESSFUL;                                          
  }                                                                   
                                                                      
  disktab = calloc(size, sizeof(rtems_disk_device_table));            
40004980:	90 10 20 08 	mov  8, %o0                                    
40004984:	92 10 20 08 	mov  8, %o1                                    
40004988:	40 00 02 3a 	call  40005270 <calloc>                        
4000498c:	39 10 00 71 	sethi  %hi(0x4001c400), %i4                    
40004990:	d0 27 20 74 	st  %o0, [ %i4 + 0x74 ]	! 4001c474 <disktab>   
  if (disktab == NULL) {                                              
40004994:	80 a2 20 00 	cmp  %o0, 0                                    
40004998:	02 80 00 11 	be  400049dc <rtems_disk_io_initialize+0x74>   <== NEVER TAKEN
4000499c:	b0 10 20 1a 	mov  0x1a, %i0                                 
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  diskdevs_protected = false;                                         
400049a0:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
  sc = rtems_semaphore_create(                                        
400049a4:	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;                                         
400049a8:	c0 28 60 68 	clrb  [ %g1 + 0x68 ]                           
  sc = rtems_semaphore_create(                                        
400049ac:	90 12 21 56 	or  %o0, 0x156, %o0                            
400049b0:	92 10 20 01 	mov  1, %o1                                    
400049b4:	94 10 20 10 	mov  0x10, %o2                                 
400049b8:	96 10 20 00 	clr  %o3                                       
400049bc:	37 10 00 71 	sethi  %hi(0x4001c400), %i3                    
400049c0:	40 00 13 60 	call  40009740 <rtems_semaphore_create>        
400049c4:	98 16 e0 6c 	or  %i3, 0x6c, %o4	! 4001c46c <diskdevs_mutex> 
    RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY   
      | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,                      
    0,                                                                
    &diskdevs_mutex                                                   
  );                                                                  
  if (sc != RTEMS_SUCCESSFUL) {                                       
400049c8:	80 a2 20 00 	cmp  %o0, 0                                    
400049cc:	02 80 00 06 	be  400049e4 <rtems_disk_io_initialize+0x7c>   <== ALWAYS TAKEN
400049d0:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  sc = rtems_bdbuf_init();                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
    rtems_semaphore_delete(diskdevs_mutex);                           
    free(disktab);                                                    
400049d4:	40 00 02 5e 	call  4000534c <free>                          <== NOT EXECUTED
400049d8:	d0 07 20 74 	ld  [ %i4 + 0x74 ], %o0                        <== NOT EXECUTED
                                                                      
    return RTEMS_UNSATISFIED;                                         
400049dc:	81 c7 e0 08 	ret                                            
400049e0:	81 e8 00 00 	restore                                        
    free(disktab);                                                    
                                                                      
    return RTEMS_NO_MEMORY;                                           
  }                                                                   
                                                                      
  sc = rtems_bdbuf_init();                                            
400049e4:	40 00 2b df 	call  4000f960 <rtems_bdbuf_init>              
400049e8:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
400049ec:	80 a2 20 00 	cmp  %o0, 0                                    
400049f0:	12 80 00 05 	bne  40004a04 <rtems_disk_io_initialize+0x9c>  <== NEVER TAKEN
400049f4:	82 10 20 08 	mov  8, %g1                                    
    free(disktab);                                                    
                                                                      
    return RTEMS_UNSATISFIED;                                         
  }                                                                   
                                                                      
  disktab_size = size;                                                
400049f8:	c2 27 60 70 	st  %g1, [ %i5 + 0x70 ]                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400049fc:	81 c7 e0 08 	ret                                            
40004a00:	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);                           
40004a04:	d0 06 e0 6c 	ld  [ %i3 + 0x6c ], %o0                        <== NOT EXECUTED
40004a08:	40 00 13 bf 	call  40009904 <rtems_semaphore_delete>        <== NOT EXECUTED
40004a0c:	b0 10 20 0d 	mov  0xd, %i0                                  <== NOT EXECUTED
40004a10:	30 bf ff f1 	b,a   400049d4 <rtems_disk_io_initialize+0x6c> <== NOT EXECUTED
                                                                      

40004870 <rtems_disk_next>: rtems_disk_device * rtems_disk_next(dev_t dev) {
40004870:	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) {                                            
40004874:	80 a6 3f ff 	cmp  %i0, -1                                   
40004878:	02 80 00 37 	be  40004954 <rtems_disk_next+0xe4>            
4000487c:	80 a6 7f ff 	cmp  %i1, -1                                   
    rtems_filesystem_split_dev_t(dev, major, minor);                  
                                                                      
    /* If minor wraps around */                                       
    if ((minor + 1) < minor) {                                        
40004880:	ba 06 60 01 	add  %i1, 1, %i5                               
40004884:	80 a7 40 19 	cmp  %i5, %i1                                  
40004888:	0a 80 00 2e 	bcs  40004940 <rtems_disk_next+0xd0>           <== NEVER TAKEN
4000488c:	b8 10 00 18 	mov  %i0, %i4                                  
    } else {                                                          
      ++minor;                                                        
    }                                                                 
  }                                                                   
                                                                      
  sc = disk_lock();                                                   
40004890:	7f ff fe 57 	call  400041ec <disk_lock>                     
40004894:	01 00 00 00 	nop                                            
  if (sc != RTEMS_SUCCESSFUL) {                                       
40004898:	80 a2 20 00 	cmp  %o0, 0                                    
4000489c:	12 80 00 27 	bne  40004938 <rtems_disk_next+0xc8>           <== NEVER TAKEN
400048a0:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
    return NULL;                                                      
  }                                                                   
                                                                      
  if (major >= disktab_size) {                                        
400048a4:	c8 00 60 70 	ld  [ %g1 + 0x70 ], %g4	! 4001c470 <disktab_size>
400048a8:	80 a7 00 04 	cmp  %i4, %g4                                  
400048ac:	1a 80 00 21 	bcc  40004930 <rtems_disk_next+0xc0>           <== NEVER TAKEN
400048b0:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
    disk_unlock();                                                    
                                                                      
    return NULL;                                                      
  }                                                                   
                                                                      
  dtab = disktab + major;                                             
400048b4:	c6 00 60 74 	ld  [ %g1 + 0x74 ], %g3	! 4001c474 <disktab>   
400048b8:	b7 2f 20 03 	sll  %i4, 3, %i3                               
400048bc:	c2 00 c0 1b 	ld  [ %g3 + %i3 ], %g1                         
400048c0:	b6 00 c0 1b 	add  %g3, %i3, %i3                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
400048c4:	80 a0 60 00 	cmp  %g1, 0                                    
400048c8:	02 80 00 12 	be  40004910 <rtems_disk_next+0xa0>            
400048cc:	b5 2f 60 02 	sll  %i5, 2, %i2                               
400048d0:	c4 06 e0 04 	ld  [ %i3 + 4 ], %g2                           
400048d4:	80 a7 40 02 	cmp  %i5, %g2                                  
400048d8:	3a 80 00 0f 	bcc,a   40004914 <rtems_disk_next+0xa4>        
400048dc:	b8 07 20 01 	inc  %i4                                       
         disk_unlock();                                               
                                                                      
         return NULL;                                                 
       }                                                              
       dtab = disktab + major;                                        
    } else if (dtab->minor [minor] == NULL) {                         
400048e0:	c4 00 40 1a 	ld  [ %g1 + %i2 ], %g2                         
400048e4:	80 a0 a0 00 	cmp  %g2, 0                                    
400048e8:	02 bf ff f7 	be  400048c4 <rtems_disk_next+0x54>            
400048ec:	ba 07 60 01 	inc  %i5                                       
      ++minor;                                                        
    } else {                                                          
      ++dtab->minor [minor]->uses;                                    
400048f0:	c2 00 a0 14 	ld  [ %g2 + 0x14 ], %g1                        
400048f4:	82 00 60 01 	inc  %g1                                       
      disk_unlock();                                                  
400048f8:	7f ff fe 4c 	call  40004228 <disk_unlock>                   
400048fc:	c2 20 a0 14 	st  %g1, [ %g2 + 0x14 ]                        
                                                                      
      return dtab->minor [minor];                                     
40004900:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
40004904:	f0 00 40 1a 	ld  [ %g1 + %i2 ], %i0                         
    }                                                                 
  }                                                                   
}                                                                     
40004908:	81 c7 e0 08 	ret                                            
4000490c:	81 e8 00 00 	restore                                        
                                                                      
  dtab = disktab + major;                                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
       minor = 0;                                                     
       ++major;                                                       
40004910:	b8 07 20 01 	inc  %i4                                       
       if (major >= disktab_size) {                                   
40004914:	80 a1 00 1c 	cmp  %g4, %i4                                  
40004918:	08 80 00 06 	bleu  40004930 <rtems_disk_next+0xc0>          
4000491c:	83 2f 20 03 	sll  %i4, 3, %g1                               
  }                                                                   
                                                                      
  dtab = disktab + major;                                             
  while (true) {                                                      
    if (dtab->minor == NULL || minor >= dtab->size) {                 
       minor = 0;                                                     
40004920:	ba 10 20 00 	clr  %i5                                       
       if (major >= disktab_size) {                                   
         disk_unlock();                                               
                                                                      
         return NULL;                                                 
       }                                                              
       dtab = disktab + major;                                        
40004924:	b6 00 c0 01 	add  %g3, %g1, %i3                             
40004928:	10 bf ff e7 	b  400048c4 <rtems_disk_next+0x54>             
4000492c:	c2 00 c0 01 	ld  [ %g3 + %g1 ], %g1                         
  if (sc != RTEMS_SUCCESSFUL) {                                       
    return NULL;                                                      
  }                                                                   
                                                                      
  if (major >= disktab_size) {                                        
    disk_unlock();                                                    
40004930:	7f ff fe 3e 	call  40004228 <disk_unlock>                   
40004934:	01 00 00 00 	nop                                            
                                                                      
    return NULL;                                                      
40004938:	81 c7 e0 08 	ret                                            
4000493c:	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) {                                      
40004940:	b8 06 20 01 	add  %i0, 1, %i4                               <== NOT EXECUTED
40004944:	80 a7 00 18 	cmp  %i4, %i0                                  <== NOT EXECUTED
40004948:	1a bf ff d2 	bcc  40004890 <rtems_disk_next+0x20>           <== NOT EXECUTED
4000494c:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
40004950:	30 bf ff fa 	b,a   40004938 <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) {                                            
40004954:	32 bf ff cc 	bne,a   40004884 <rtems_disk_next+0x14>        <== NEVER TAKEN
40004958:	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;                                
4000495c:	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;                                
40004960:	10 bf ff cc 	b  40004890 <rtems_disk_next+0x20>             
40004964:	b8 10 20 00 	clr  %i4                                       
                                                                      

400047a0 <rtems_disk_obtain>: return RTEMS_SUCCESSFUL; } rtems_disk_device * rtems_disk_obtain(dev_t dev) {
400047a0:	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);                                     
400047a4:	7f ff f9 05 	call  40002bb8 <sparc_disable_interrupts>      
400047a8:	b8 10 00 18 	mov  %i0, %i4                                  
400047ac:	b6 10 00 08 	mov  %o0, %i3                                  
  if (!diskdevs_protected) {                                          
400047b0:	03 10 00 71 	sethi  %hi(0x4001c400), %g1                    
400047b4:	c2 08 60 68 	ldub  [ %g1 + 0x68 ], %g1	! 4001c468 <diskdevs_protected>
400047b8:	80 a0 60 00 	cmp  %g1, 0                                    
400047bc:	22 80 00 10 	be,a   400047fc <rtems_disk_obtain+0x5c>       <== ALWAYS TAKEN
400047c0:	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);                                    
400047c4:	7f ff f9 01 	call  40002bc8 <sparc_enable_interrupts>       <== NOT EXECUTED
400047c8:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      
    sc = disk_lock();                                                 
400047cc:	7f ff fe 88 	call  400041ec <disk_lock>                     <== NOT EXECUTED
400047d0:	01 00 00 00 	nop                                            <== NOT EXECUTED
    if (sc == RTEMS_SUCCESSFUL) {                                     
400047d4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400047d8:	12 80 00 07 	bne  400047f4 <rtems_disk_obtain+0x54>         <== NOT EXECUTED
400047dc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
      dd = get_disk_entry(dev, false);                                
400047e0:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
400047e4:	7f ff fe 45 	call  400040f8 <get_disk_entry>                <== NOT EXECUTED
400047e8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
      disk_unlock();                                                  
400047ec:	7f ff fe 8f 	call  40004228 <disk_unlock>                   <== NOT EXECUTED
400047f0:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    }                                                                 
  }                                                                   
                                                                      
  return dd;                                                          
}                                                                     
400047f4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400047f8:	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);                                  
400047fc:	92 10 00 19 	mov  %i1, %o1                                  
40004800:	7f ff fe 3e 	call  400040f8 <get_disk_entry>                
40004804:	94 10 20 00 	clr  %o2                                       
40004808:	b0 10 00 08 	mov  %o0, %i0                                  
    rtems_interrupt_enable(level);                                    
4000480c:	7f ff f8 ef 	call  40002bc8 <sparc_enable_interrupts>       
40004810:	90 10 00 1b 	mov  %i3, %o0                                  
40004814:	81 c7 e0 08 	ret                                            
40004818:	81 e8 00 00 	restore                                        
                                                                      

40012900 <rtems_event_system_receive>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) {
40012900:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc;                                               
                                                                      
  if ( event_out != NULL ) {                                          
40012904:	80 a6 e0 00 	cmp  %i3, 0                                    
40012908:	02 80 00 0a 	be  40012930 <rtems_event_system_receive+0x30> <== NEVER TAKEN
4001290c:	82 10 20 09 	mov  9, %g1                                    
    Thread_Control    *executing = _Thread_Executing;                 
40012910:	03 10 00 73 	sethi  %hi(0x4001cc00), %g1                    
40012914:	fa 00 63 c0 	ld  [ %g1 + 0x3c0 ], %i5	! 4001cfc0 <_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 ) ) {                        
40012918:	80 a6 20 00 	cmp  %i0, 0                                    
4001291c:	12 80 00 07 	bne  40012938 <rtems_event_system_receive+0x38><== ALWAYS TAKEN
40012920:	da 07 61 4c 	ld  [ %i5 + 0x14c ], %o5                       
      );                                                              
      _Thread_Enable_dispatch();                                      
                                                                      
      sc = executing->Wait.return_code;                               
    } else {                                                          
      *event_out = event->pending_events;                             
40012924:	c4 03 60 04 	ld  [ %o5 + 4 ], %g2                           <== NOT EXECUTED
      sc = RTEMS_SUCCESSFUL;                                          
40012928:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
      );                                                              
      _Thread_Enable_dispatch();                                      
                                                                      
      sc = executing->Wait.return_code;                               
    } else {                                                          
      *event_out = event->pending_events;                             
4001292c:	c4 26 c0 00 	st  %g2, [ %i3 ]                               <== NOT EXECUTED
  } else {                                                            
    sc = RTEMS_INVALID_ADDRESS;                                       
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
40012930:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012934:	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;                  
40012938:	03 10 00 72 	sethi  %hi(0x4001c800), %g1                    
4001293c:	c4 00 62 a0 	ld  [ %g1 + 0x2a0 ], %g2	! 4001caa0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
40012940:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40012944:	c4 20 62 a0 	st  %g2, [ %g1 + 0x2a0 ]                       
    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(                                                   
40012948:	03 00 01 00 	sethi  %hi(0x40000), %g1                       
4001294c:	90 10 00 18 	mov  %i0, %o0                                  
40012950:	92 10 00 19 	mov  %i1, %o1                                  
40012954:	94 10 00 1a 	mov  %i2, %o2                                  
40012958:	96 10 00 1b 	mov  %i3, %o3                                  
4001295c:	98 10 00 1d 	mov  %i5, %o4                                  
40012960:	9a 03 60 04 	add  %o5, 4, %o5                               
40012964:	c2 23 a0 60 	st  %g1, [ %sp + 0x60 ]                        
40012968:	03 10 00 74 	sethi  %hi(0x4001d000), %g1                    
4001296c:	82 10 63 b0 	or  %g1, 0x3b0, %g1	! 4001d3b0 <_System_event_Sync_state>
40012970:	7f ff da a1 	call  400093f4 <_Event_Seize>                  
40012974:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
        executing,                                                    
        event,                                                        
        &_System_event_Sync_state,                                    
        STATES_WAITING_FOR_SYSTEM_EVENT                               
      );                                                              
      _Thread_Enable_dispatch();                                      
40012978:	7f ff e7 34 	call  4000c648 <_Thread_Enable_dispatch>       
4001297c:	01 00 00 00 	nop                                            
                                                                      
      sc = executing->Wait.return_code;                               
40012980:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
  } else {                                                            
    sc = RTEMS_INVALID_ADDRESS;                                       
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
40012984:	81 c7 e0 08 	ret                                            
40012988:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

40008774 <rtems_event_system_send>: rtems_status_code rtems_event_system_send( rtems_id id, rtems_event_set event_in ) {
40008774:	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 );                              
40008778:	90 10 00 18 	mov  %i0, %o0                                  
4000877c:	40 00 0a 5f 	call  4000b0f8 <_Thread_Get>                   
40008780:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
40008784:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008788:	80 a0 60 00 	cmp  %g1, 0                                    
4000878c:	12 80 00 0d 	bne  400087c0 <rtems_event_system_send+0x4c>   <== NEVER TAKEN
40008790:	92 10 00 19 	mov  %i1, %o1                                  
    case OBJECTS_LOCAL:                                               
      api = thread->API_Extensions[ THREAD_API_RTEMS ];               
      _Event_Surrender(                                               
40008794:	d4 02 21 4c 	ld  [ %o0 + 0x14c ], %o2                       
40008798:	94 02 a0 04 	add  %o2, 4, %o2                               
4000879c:	19 00 01 00 	sethi  %hi(0x40000), %o4                       
400087a0:	17 10 00 82 	sethi  %hi(0x40020800), %o3                    
400087a4:	96 12 e3 c0 	or  %o3, 0x3c0, %o3	! 40020bc0 <_System_event_Sync_state>
400087a8:	7f ff fe 54 	call  400080f8 <_Event_Surrender>              
400087ac:	b0 10 20 00 	clr  %i0                                       
        event_in,                                                     
        &api->System_event,                                           
        &_System_event_Sync_state,                                    
        STATES_WAITING_FOR_SYSTEM_EVENT                               
      );                                                              
      _Thread_Enable_dispatch();                                      
400087b0:	40 00 0a 46 	call  4000b0c8 <_Thread_Enable_dispatch>       
400087b4:	01 00 00 00 	nop                                            
      sc = RTEMS_SUCCESSFUL;                                          
      break;                                                          
400087b8:	81 c7 e0 08 	ret                                            
400087bc:	81 e8 00 00 	restore                                        
      sc = RTEMS_INVALID_ID;                                          
      break;                                                          
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400087c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400087c4:	91 e8 20 04 	restore  %g0, 4, %o0                           <== NOT EXECUTED
                                                                      

40008780 <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, ...)
40008780:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
  fprintf (stderr, "fdisk:abort:");                                   
40008784:	31 10 00 e9 	sethi  %hi(0x4003a400), %i0                    <== NOT EXECUTED
40008788:	c2 06 21 78 	ld  [ %i0 + 0x178 ], %g1	! 4003a578 <_impure_ptr><== NOT EXECUTED
 */                                                                   
static void                                                           
rtems_fdisk_abort (const char *format, ...)                           
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
4000878c:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        <== NOT EXECUTED
40008790:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
40008794:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
40008798:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
4000879c:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        <== NOT EXECUTED
  fprintf (stderr, "fdisk:abort:");                                   
400087a0:	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);                                            
400087a4:	82 07 a0 48 	add  %fp, 0x48, %g1                            <== NOT EXECUTED
  fprintf (stderr, "fdisk:abort:");                                   
400087a8:	94 10 20 0c 	mov  0xc, %o2                                  <== NOT EXECUTED
400087ac:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
 */                                                                   
static void                                                           
rtems_fdisk_abort (const char *format, ...)                           
{                                                                     
  va_list args;                                                       
  va_start (args, format);                                            
400087b0:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
  fprintf (stderr, "fdisk:abort:");                                   
400087b4:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
400087b8:	40 00 70 dc 	call  40024b28 <fwrite>                        <== NOT EXECUTED
400087bc:	90 12 23 30 	or  %o0, 0x330, %o0	! 40035730 <Callbacks.6428+0x4e8><== NOT EXECUTED
  vfprintf (stderr, format, args);                                    
400087c0:	c2 06 21 78 	ld  [ %i0 + 0x178 ], %g1                       <== NOT EXECUTED
400087c4:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
400087c8:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
400087cc:	40 00 6f 2a 	call  40024474 <fputs>                         <== NOT EXECUTED
400087d0:	90 12 23 40 	or  %o0, 0x340, %o0                            <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
400087d4:	c2 06 21 78 	ld  [ %i0 + 0x178 ], %g1                       <== NOT EXECUTED
400087d8:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
400087dc:	40 00 6e f2 	call  400243a4 <fputc>                         <== NOT EXECUTED
400087e0:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
  fflush (stderr);                                                    
400087e4:	c2 06 21 78 	ld  [ %i0 + 0x178 ], %g1                       <== NOT EXECUTED
400087e8:	40 00 6d d7 	call  40023f44 <fflush>                        <== NOT EXECUTED
400087ec:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         <== NOT EXECUTED
  va_end (args);                                                      
  exit (1);                                                           
400087f0:	40 00 6c d5 	call  40023b44 <exit>                          <== NOT EXECUTED
400087f4:	90 10 20 01 	mov  1, %o0                                    <== NOT EXECUTED
                                                                      

40006788 <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) {
40006788:	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)                                                     
4000678c:	c4 06 20 28 	ld  [ %i0 + 0x28 ], %g2                        
40006790:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
40006794:	80 a0 80 01 	cmp  %g2, %g1                                  
40006798:	1a 80 00 20 	bcc  40006818 <rtems_fdisk_compact+0x90>       
4000679c:	a6 10 00 18 	mov  %i0, %l3                                  
    fd->starvations++;                                                
400067a0:	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");                   
400067a4:	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++;                                                
400067a8:	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");                   
400067ac:	13 10 00 d5 	sethi  %hi(0x40035400), %o1                    
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)         
{                                                                     
  bool starvation = fd->erased_blocks < fd->starvation_threshold;     
                                                                      
  if (starvation)                                                     
    fd->starvations++;                                                
400067b0:	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");                   
400067b4:	7f ff fc a7 	call  40005a50 <rtems_fdisk_printf>            
400067b8:	92 12 62 38 	or  %o1, 0x238, %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)                                                    
400067bc:	fa 06 20 40 	ld  [ %i0 + 0x40 ], %i5                        
400067c0:	80 a7 60 00 	cmp  %i5, 0                                    
400067c4:	22 80 00 83 	be,a   400069d0 <rtems_fdisk_compact+0x248>    <== NEVER TAKEN
400067c8:	fa 06 20 34 	ld  [ %i0 + 0x34 ], %i5                        <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
400067cc:	c2 07 40 00 	ld  [ %i5 ], %g1                               
    if (!queue->head)                                                 
400067d0:	80 a0 60 00 	cmp  %g1, 0                                    
400067d4:	02 80 00 9f 	be  40006a50 <rtems_fdisk_compact+0x2c8>       <== NEVER TAKEN
400067d8:	c2 26 20 40 	st  %g1, [ %i0 + 0x40 ]                        
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
400067dc:	c2 04 e0 48 	ld  [ %l3 + 0x48 ], %g1                        
400067e0:	82 00 7f ff 	add  %g1, -1, %g1                              
400067e4:	c2 24 e0 48 	st  %g1, [ %l3 + 0x48 ]                        
                                                                      
    sc->next = 0;                                                     
400067e8:	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);          
400067ec:	7f ff fc 59 	call  40005950 <rtems_fdisk_seg_most_available>
400067f0:	90 04 e0 34 	add  %l3, 0x34, %o0                            
      if (dsc)                                                        
400067f4:	94 92 20 00 	orcc  %o0, 0, %o2                              
400067f8:	02 80 00 8b 	be  40006a24 <rtems_fdisk_compact+0x29c>       <== NEVER TAKEN
400067fc:	92 10 00 1d 	mov  %i5, %o1                                  
      {                                                               
        ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);     
40006800:	90 10 00 13 	mov  %l3, %o0                                  
40006804:	7f ff fe d1 	call  40006348 <rtems_fdisk_recycle_segment>   
40006808:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (ret)                                                      
4000680c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40006810:	12 80 00 8e 	bne  40006a48 <rtems_fdisk_compact+0x2c0>      <== NEVER TAKEN
40006814:	01 00 00 00 	nop                                            
40006818:	d2 04 e0 40 	ld  [ %l3 + 0x40 ], %o1                        
  {                                                                   
    uint32_t                 dst_pages;                               
    uint32_t                 segments;                                
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " compacting");                           
4000681c:	21 10 00 d5 	sethi  %hi(0x40035400), %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",         
40006820:	23 10 00 d5 	sethi  %hi(0x40035400), %l1                    
#endif                                                                
      break;                                                          
    }                                                                 
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",       
40006824:	25 10 00 d5 	sethi  %hi(0x40035400), %l2                    
                                                                      
    while (ssc &&                                                     
           ((pages + ssc->pages_active) < dst_pages) &&               
           ((compacted_segs + segments) < fd->compact_segs))          
    {                                                                 
      pages += ssc->pages_active;                                     
40006828:	b8 10 20 00 	clr  %i4                                       
  {                                                                   
    uint32_t                 dst_pages;                               
    uint32_t                 segments;                                
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " compacting");                           
4000682c:	a0 14 22 68 	or  %l0, 0x268, %l0                            
#endif                                                                
                                                                      
    dsc = rtems_fdisk_seg_most_available (&fd->available);            
40006830:	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",         
40006834:	a2 14 62 b0 	or  %l1, 0x2b0, %l1                            
#endif                                                                
      break;                                                          
    }                                                                 
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",       
40006838:	a4 14 a2 e8 	or  %l2, 0x2e8, %l2                            
      rtems_fdisk_error ("compacting: nothing to recycle");           
      return EIO;                                                     
    }                                                                 
  }                                                                   
                                                                      
  while (fd->used.head)                                               
4000683c:	80 a2 60 00 	cmp  %o1, 0                                    
40006840:	02 80 00 70 	be  40006a00 <rtems_fdisk_compact+0x278>       
40006844:	92 10 00 10 	mov  %l0, %o1                                  
  {                                                                   
    uint32_t                 dst_pages;                               
    uint32_t                 segments;                                
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " compacting");                           
40006848:	7f ff fc 82 	call  40005a50 <rtems_fdisk_printf>            
4000684c:	90 10 00 13 	mov  %l3, %o0                                  
#endif                                                                
                                                                      
    dsc = rtems_fdisk_seg_most_available (&fd->available);            
40006850:	7f ff fc 40 	call  40005950 <rtems_fdisk_seg_most_available>
40006854:	90 10 00 19 	mov  %i1, %o0                                  
                                                                      
    if (dsc == 0)                                                     
40006858:	b4 92 20 00 	orcc  %o0, 0, %i2                              
4000685c:	02 80 00 6b 	be  40006a08 <rtems_fdisk_compact+0x280>       <== NEVER TAKEN
40006860:	11 10 00 d5 	sethi  %hi(0x40035400), %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)                             
40006864:	f6 06 a0 24 	ld  [ %i2 + 0x24 ], %i3                        
40006868:	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);
4000686c:	c4 06 a0 14 	ld  [ %i2 + 0x14 ], %g2                        
40006870:	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",         
40006874:	d4 06 a0 08 	ld  [ %i2 + 8 ], %o2                           
40006878:	d6 06 a0 0c 	ld  [ %i2 + 0xc ], %o3                         
    {                                                                 
      rtems_fdisk_error ("compacting: no available segments to compact too");
      return EIO;                                                     
    }                                                                 
                                                                      
    ssc = fd->used.head;                                              
4000687c:	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)                             
40006880:	b6 06 c0 03 	add  %i3, %g3, %i3                             
    }                                                                 
                                                                      
    ssc = fd->used.head;                                              
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
    segments = 0;                                                     
    pages = 0;                                                        
40006884:	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);
40006888:	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",         
4000688c:	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);
40006890:	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",         
40006894:	7f ff fc 6f 	call  40005a50 <rtems_fdisk_printf>            
40006898:	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 &&                                                     
4000689c:	80 a7 60 00 	cmp  %i5, 0                                    
400068a0:	02 80 00 1b 	be  4000690c <rtems_fdisk_compact+0x184>       <== NEVER TAKEN
400068a4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
           ((pages + ssc->pages_active) < dst_pages) &&               
400068a8:	d8 07 60 1c 	ld  [ %i5 + 0x1c ], %o4                        
400068ac:	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 &&                                                     
400068b0:	80 a6 c0 0c 	cmp  %i3, %o4                                  
400068b4:	28 80 00 45 	bleu,a   400069c8 <rtems_fdisk_compact+0x240>  
400068b8:	98 10 00 01 	mov  %g1, %o4                                  
           ((pages + ssc->pages_active) < dst_pages) &&               
           ((compacted_segs + segments) < fd->compact_segs))          
400068bc:	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) &&               
400068c0:	80 a7 00 03 	cmp  %i4, %g3                                  
400068c4:	3a 80 00 41 	bcc,a   400069c8 <rtems_fdisk_compact+0x240>   <== NEVER TAKEN
400068c8:	98 10 00 01 	mov  %g1, %o4                                  <== NOT EXECUTED
400068cc:	10 80 00 0b 	b  400068f8 <rtems_fdisk_compact+0x170>        
400068d0:	9a 10 20 00 	clr  %o5                                       
400068d4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
400068d8:	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 &&                                                     
400068dc:	80 a0 40 1b 	cmp  %g1, %i3                                  
400068e0:	1a 80 00 12 	bcc  40006928 <rtems_fdisk_compact+0x1a0>      
400068e4:	84 07 00 0d 	add  %i4, %o5, %g2                             
           ((pages + ssc->pages_active) < dst_pages) &&               
400068e8:	80 a0 80 03 	cmp  %g2, %g3                                  
400068ec:	3a 80 00 10 	bcc,a   4000692c <rtems_fdisk_compact+0x1a4>   <== NEVER TAKEN
400068f0:	d8 27 bf fc 	st  %o4, [ %fp + -4 ]                          <== NOT EXECUTED
400068f4:	98 10 00 01 	mov  %g1, %o4                                  
           ((compacted_segs + segments) < fd->compact_segs))          
    {                                                                 
      pages += ssc->pages_active;                                     
      segments++;                                                     
      ssc = ssc->next;                                                
400068f8:	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 &&                                                     
400068fc:	80 a7 60 00 	cmp  %i5, 0                                    
40006900:	12 bf ff f5 	bne  400068d4 <rtems_fdisk_compact+0x14c>      
40006904:	9a 03 60 01 	inc  %o5                                       
40006908:	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");                 
4000690c:	90 10 00 13 	mov  %l3, %o0                                  
40006910:	13 10 00 d5 	sethi  %hi(0x40035400), %o1                    
    }                                                                 
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
40006914:	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");                 
40006918:	7f ff fc 4e 	call  40005a50 <rtems_fdisk_printf>            
4000691c:	92 12 62 d0 	or  %o1, 0x2d0, %o1                            
#endif                                                                
      break;                                                          
40006920:	81 c7 e0 08 	ret                                            
40006924:	81 e8 00 00 	restore                                        
40006928:	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))   
4000692c:	80 a3 20 00 	cmp  %o4, 0                                    
40006930:	02 bf ff f8 	be  40006910 <rtems_fdisk_compact+0x188>       
40006934:	90 10 00 13 	mov  %l3, %o0                                  
40006938:	b8 07 00 0d 	add  %i4, %o5, %i4                             
4000693c:	80 a7 20 01 	cmp  %i4, 1                                    
40006940:	22 bf ff f5 	be,a   40006914 <rtems_fdisk_compact+0x18c>    
40006944:	13 10 00 d5 	sethi  %hi(0x40035400), %o1                    
#endif                                                                
      break;                                                          
    }                                                                 
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",       
40006948:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           
4000694c:	d6 07 60 0c 	ld  [ %i5 + 0xc ], %o3                         
40006950:	92 10 00 12 	mov  %l2, %o1                                  
40006954:	7f ff fc 3f 	call  40005a50 <rtems_fdisk_printf>            
40006958:	90 10 00 13 	mov  %l3, %o0                                  
                        ssc->device, ssc->segment,                    
                        pages, segments);                             
#endif                                                                
                                                                      
    rtems_fdisk_segment_queue_remove (&fd->available, dsc);           
4000695c:	90 10 00 19 	mov  %i1, %o0                                  
40006960:	7f ff fb 9b 	call  400057cc <rtems_fdisk_segment_queue_remove>
40006964:	92 10 00 1a 	mov  %i2, %o1                                  
40006968:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000696c:	d2 04 e0 40 	ld  [ %l3 + 0x40 ], %o1                        
                                                                      
    /*                                                                
     * We now copy the pages to the new segment.                      
     */                                                               
                                                                      
    while (pages)                                                     
40006970:	80 a0 60 00 	cmp  %g1, 0                                    
40006974:	02 bf ff b3 	be  40006840 <rtems_fdisk_compact+0xb8>        
40006978:	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)                                                    
4000697c:	02 bf ff fe 	be  40006974 <rtems_fdisk_compact+0x1ec>       <== NEVER TAKEN
40006980:	80 a0 60 00 	cmp  %g1, 0                                    
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
40006984:	c2 02 40 00 	ld  [ %o1 ], %g1                               
    if (!queue->head)                                                 
40006988:	80 a0 60 00 	cmp  %g1, 0                                    
4000698c:	02 80 00 24 	be  40006a1c <rtems_fdisk_compact+0x294>       <== NEVER TAKEN
40006990:	c2 24 e0 40 	st  %g1, [ %l3 + 0x40 ]                        
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
40006994:	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);     
40006998:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
    queue->head = sc->next;                                           
    if (!queue->head)                                                 
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
4000699c:	82 00 7f ff 	add  %g1, -1, %g1                              
400069a0:	c2 24 e0 48 	st  %g1, [ %l3 + 0x48 ]                        
                                                                      
    sc->next = 0;                                                     
400069a4:	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);     
400069a8:	94 10 00 1a 	mov  %i2, %o2                                  
400069ac:	7f ff fe 67 	call  40006348 <rtems_fdisk_recycle_segment>   
400069b0:	96 07 bf fc 	add  %fp, -4, %o3                              
        if (ret)                                                      
400069b4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400069b8:	02 bf ff ed 	be  4000696c <rtems_fdisk_compact+0x1e4>       <== ALWAYS TAKEN
400069bc:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
400069c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400069c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      return EIO;                                                     
    }                                                                 
                                                                      
    ssc = fd->used.head;                                              
    dst_pages = rtems_fdisk_seg_pages_available (dsc);                
    segments = 0;                                                     
400069c8:	10 bf ff d9 	b  4000692c <rtems_fdisk_compact+0x1a4>        
400069cc:	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)                                                    
400069d0:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
400069d4:	02 80 00 1a 	be  40006a3c <rtems_fdisk_compact+0x2b4>       <== NOT EXECUTED
400069d8:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
400069dc:	c2 07 40 00 	ld  [ %i5 ], %g1                               <== NOT EXECUTED
    if (!queue->head)                                                 
400069e0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400069e4:	02 80 00 1d 	be  40006a58 <rtems_fdisk_compact+0x2d0>       <== NOT EXECUTED
400069e8:	c2 24 e0 34 	st  %g1, [ %l3 + 0x34 ]                        <== NOT EXECUTED
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
400069ec:	c2 04 e0 3c 	ld  [ %l3 + 0x3c ], %g1                        <== NOT EXECUTED
400069f0:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
400069f4:	c2 24 e0 3c 	st  %g1, [ %l3 + 0x3c ]                        <== NOT EXECUTED
                                                                      
    sc->next = 0;                                                     
400069f8:	10 bf ff 7d 	b  400067ec <rtems_fdisk_compact+0x64>         <== NOT EXECUTED
400069fc:	c0 27 40 00 	clr  [ %i5 ]                                   <== NOT EXECUTED
    }                                                                 
                                                                      
    compacted_segs += segments;                                       
  }                                                                   
                                                                      
  return 0;                                                           
40006a00:	81 c7 e0 08 	ret                                            
40006a04:	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;                                                     
40006a08:	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");
40006a0c:	7f ff fc eb 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40006a10:	90 12 22 78 	or  %o0, 0x278, %o0                            <== NOT EXECUTED
40006a14:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006a18:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
    if (!queue->head)                                                 
      queue->tail = 0;                                                
40006a1c:	10 bf ff de 	b  40006994 <rtems_fdisk_compact+0x20c>        <== NOT EXECUTED
40006a20:	c0 24 e0 44 	clr  [ %l3 + 0x44 ]                            <== NOT EXECUTED
        if (ret)                                                      
          return ret;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_fdisk_error ("compacting: starvation");                 
40006a24:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
        return EIO;                                                   
40006a28:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
        if (ret)                                                      
          return ret;                                                 
      }                                                               
      else                                                            
      {                                                               
        rtems_fdisk_error ("compacting: starvation");                 
40006a2c:	7f ff fc e3 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40006a30:	90 12 22 50 	or  %o0, 0x250, %o0                            <== NOT EXECUTED
40006a34:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006a38:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      rtems_fdisk_error ("compacting: nothing to recycle");           
      return EIO;                                                     
40006a3c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
        return EIO;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      rtems_fdisk_error ("compacting: nothing to recycle");           
40006a40:	7f ff fc de 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40006a44:	90 12 23 10 	or  %o0, 0x310, %o0                            <== NOT EXECUTED
40006a48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006a4c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
    if (!queue->head)                                                 
      queue->tail = 0;                                                
40006a50:	10 bf ff 63 	b  400067dc <rtems_fdisk_compact+0x54>         <== NOT EXECUTED
40006a54:	c0 26 20 44 	clr  [ %i0 + 0x44 ]                            <== NOT EXECUTED
40006a58:	10 bf ff e5 	b  400069ec <rtems_fdisk_compact+0x264>        <== NOT EXECUTED
40006a5c:	c0 24 e0 38 	clr  [ %l3 + 0x38 ]                            <== NOT EXECUTED
                                                                      

40005e34 <rtems_fdisk_erase_segment>: /** * Erase the segment. */ static int rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc) {
40005e34:	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;                                                
40005e38:	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;            
40005e3c:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
40005e40:	87 2a 60 04 	sll  %o1, 4, %g3                               
40005e44:	83 2a 60 02 	sll  %o1, 2, %g1                               
40005e48:	82 20 c0 01 	sub  %g3, %g1, %g1                             
40005e4c:	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;                    
40005e50:	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;                                              
40005e54:	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);                             
40005e58:	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;            
40005e5c:	c6 00 80 01 	ld  [ %g2 + %g1 ], %g3                         
40005e60:	89 2a a0 06 	sll  %o2, 6, %g4                               
40005e64:	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);                             
40005e68:	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;            
40005e6c:	84 21 00 02 	sub  %g4, %g2, %g2                             
40005e70:	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);                             
40005e74:	d0 00 a0 04 	ld  [ %g2 + 4 ], %o0                           
40005e78:	9f c0 40 00 	call  %g1                                      
40005e7c:	ba 10 00 18 	mov  %i0, %i5                                  
  if (ret)                                                            
40005e80:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40005e84:	22 80 00 24 	be,a   40005f14 <rtems_fdisk_erase_segment+0xe0><== ALWAYS TAKEN
40005e88:	c6 07 60 28 	ld  [ %i5 + 0x28 ], %g3                        
  {                                                                   
    rtems_fdisk_error (" erase-segment:%02d-%03d: "      \            
40005e8c:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           <== NOT EXECUTED
40005e90:	40 00 81 05 	call  400262a4 <strerror>                      <== NOT EXECUTED
40005e94:	f8 06 60 0c 	ld  [ %i1 + 0xc ], %i4                         <== NOT EXECUTED
40005e98:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40005e9c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
40005ea0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
40005ea4:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40005ea8:	98 10 00 18 	mov  %i0, %o4                                  <== NOT EXECUTED
40005eac:	7f ff ff c3 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40005eb0:	90 12 20 20 	or  %o0, 0x20, %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;                         
40005eb4:	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;                                                
40005eb8:	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)                                                          
40005ebc:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005ec0:	02 80 00 36 	be  40005f98 <rtems_fdisk_erase_segment+0x164> <== NOT EXECUTED
40005ec4:	c4 26 60 28 	st  %g2, [ %i1 + 0x28 ]                        <== NOT EXECUTED
  {                                                                   
    if (it == sc)                                                     
40005ec8:	80 a6 40 01 	cmp  %i1, %g1                                  <== NOT EXECUTED
40005ecc:	32 80 00 06 	bne,a   40005ee4 <rtems_fdisk_erase_segment+0xb0><== NOT EXECUTED
40005ed0:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
40005ed4:	30 80 00 35 	b,a   40005fa8 <rtems_fdisk_erase_segment+0x174><== NOT EXECUTED
40005ed8:	02 80 00 34 	be  40005fa8 <rtems_fdisk_erase_segment+0x174> <== NOT EXECUTED
40005edc:	01 00 00 00 	nop                                            <== NOT EXECUTED
      return true;                                                    
    it = it->next;                                                    
40005ee0:	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)                                                          
40005ee4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005ee8:	12 bf ff fc 	bne  40005ed8 <rtems_fdisk_erase_segment+0xa4> <== NOT EXECUTED
40005eec:	80 a6 40 01 	cmp  %i1, %g1                                  <== NOT EXECUTED
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40005ef0:	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;                                                     
40005ef4:	c0 26 40 00 	clr  [ %i1 ]                                   <== NOT EXECUTED
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40005ef8:	f2 20 40 00 	st  %i1, [ %g1 ]                               <== NOT EXECUTED
      queue->tail       = sc;                                         
40005efc:	f2 27 60 5c 	st  %i1, [ %i5 + 0x5c ]                        <== NOT EXECUTED
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40005f00:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        <== NOT EXECUTED
40005f04:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40005f08:	c2 27 60 60 	st  %g1, [ %i5 + 0x60 ]                        <== NOT EXECUTED
40005f0c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005f10:	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++;                                                       
40005f14:	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;                                     
40005f18:	c4 06 60 14 	ld  [ %i1 + 0x14 ], %g2                        
  sc->erased++;                                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40005f1c:	d2 06 60 18 	ld  [ %i1 + 0x18 ], %o1                        
40005f20:	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++;                                                       
40005f24:	82 00 60 01 	inc  %g1                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40005f28:	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;                                     
40005f2c:	84 00 c0 02 	add  %g3, %g2, %g2                             
40005f30:	c4 27 60 28 	st  %g2, [ %i5 + 0x28 ]                        
  sc->erased++;                                                       
                                                                      
  memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
40005f34:	7f ff f1 a1 	call  400025b8 <.umul>                         
40005f38:	c2 26 60 2c 	st  %g1, [ %i1 + 0x2c ]                        
40005f3c:	92 10 20 ff 	mov  0xff, %o1                                 
40005f40:	94 10 00 08 	mov  %o0, %o2                                  
40005f44:	40 00 7c 10 	call  40024f84 <memset>                        
40005f48:	90 10 00 1c 	mov  %i4, %o0                                  
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
40005f4c:	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;                                               
40005f50:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  sc->pages_used   = 0;                                               
40005f54:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
  sc->pages_bad    = 0;                                               
40005f58:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            
                                                                      
  sc->failed = false;                                                 
40005f5c:	c0 26 60 28 	clr  [ %i1 + 0x28 ]                            
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
40005f60:	80 a0 60 00 	cmp  %g1, 0                                    
40005f64:	02 80 00 0a 	be  40005f8c <rtems_fdisk_erase_segment+0x158> 
40005f68:	c0 26 40 00 	clr  [ %i1 ]                                   
    {                                                                 
      queue->tail->next = sc;                                         
40005f6c:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
40005f70:	f2 20 40 00 	st  %i1, [ %g1 ]                               
      queue->tail       = sc;                                         
40005f74:	f2 27 60 38 	st  %i1, [ %i5 + 0x38 ]                        
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40005f78:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
40005f7c:	82 00 60 01 	inc  %g1                                       
40005f80:	c2 27 60 3c 	st  %g1, [ %i5 + 0x3c ]                        
40005f84:	81 c7 e0 08 	ret                                            
40005f88:	81 e8 00 00 	restore                                        
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
40005f8c:	f2 27 60 38 	st  %i1, [ %i5 + 0x38 ]                        
40005f90:	10 bf ff fa 	b  40005f78 <rtems_fdisk_erase_segment+0x144>  
40005f94:	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;                                                     
40005f98:	c0 26 40 00 	clr  [ %i1 ]                                   <== NOT EXECUTED
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
40005f9c:	f2 27 60 5c 	st  %i1, [ %i5 + 0x5c ]                        <== NOT EXECUTED
40005fa0:	10 bf ff d8 	b  40005f00 <rtems_fdisk_erase_segment+0xcc>   <== NOT EXECUTED
40005fa4:	f2 27 60 58 	st  %i1, [ %i5 + 0x58 ]                        <== NOT EXECUTED
40005fa8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005fac:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40005db8 <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, ...) {
40005db8:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
  fprintf (stderr, "fdisk:error:");                                   
40005dbc:	21 10 00 e9 	sethi  %hi(0x4003a400), %l0                    <== NOT EXECUTED
40005dc0:	c2 04 21 78 	ld  [ %l0 + 0x178 ], %g1	! 4003a578 <_impure_ptr><== NOT EXECUTED
static int                                                            
rtems_fdisk_error (const char *format, ...)                           
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
40005dc4:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        <== NOT EXECUTED
40005dc8:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
40005dcc:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
40005dd0:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
40005dd4:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        <== NOT EXECUTED
  fprintf (stderr, "fdisk:error:");                                   
40005dd8:	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);                                            
40005ddc:	82 07 a0 48 	add  %fp, 0x48, %g1                            <== NOT EXECUTED
  fprintf (stderr, "fdisk:error:");                                   
40005de0:	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);                                            
40005de4:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
  fprintf (stderr, "fdisk:error:");                                   
40005de8:	94 10 20 0c 	mov  0xc, %o2                                  <== NOT EXECUTED
40005dec:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40005df0:	40 00 7b 4e 	call  40024b28 <fwrite>                        <== NOT EXECUTED
40005df4:	90 12 20 10 	or  %o0, 0x10, %o0	! 40035410 <Callbacks.6428+0x1c8><== NOT EXECUTED
  ret =  vfprintf (stderr, format, args);                             
40005df8:	c2 04 21 78 	ld  [ %l0 + 0x178 ], %g1                       <== NOT EXECUTED
40005dfc:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
40005e00:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         <== NOT EXECUTED
40005e04:	40 00 9c ae 	call  4002d0bc <vfprintf>                      <== NOT EXECUTED
40005e08:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
40005e0c:	c2 04 21 78 	ld  [ %l0 + 0x178 ], %g1                       <== NOT EXECUTED
{                                                                     
  int ret;                                                            
  va_list args;                                                       
  va_start (args, format);                                            
  fprintf (stderr, "fdisk:error:");                                   
  ret =  vfprintf (stderr, format, args);                             
40005e10:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
  fprintf (stderr, "\n");                                             
40005e14:	d2 00 60 0c 	ld  [ %g1 + 0xc ], %o1                         <== NOT EXECUTED
40005e18:	40 00 79 63 	call  400243a4 <fputc>                         <== NOT EXECUTED
40005e1c:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
  fflush (stderr);                                                    
40005e20:	c2 04 21 78 	ld  [ %l0 + 0x178 ], %g1                       <== NOT EXECUTED
40005e24:	40 00 78 48 	call  40023f44 <fflush>                        <== NOT EXECUTED
40005e28:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         <== NOT EXECUTED
  va_end (args);                                                      
  return ret;                                                         
}                                                                     
40005e2c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005e30:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400059c8 <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, ...) {
400059c8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int ret = 0;                                                        
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
400059cc:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
400059d0:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
400059d4:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
400059d8:	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)                                            
400059dc:	c2 06 20 6c 	ld  [ %i0 + 0x6c ], %g1                        
400059e0:	80 a0 60 01 	cmp  %g1, 1                                    
400059e4:	08 80 00 19 	bleu  40005a48 <rtems_fdisk_info+0x80>         <== ALWAYS TAKEN
400059e8:	b0 10 20 00 	clr  %i0                                       
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:");                                       
400059ec:	3b 10 00 e9 	sethi  %hi(0x4003a400), %i5                    <== NOT EXECUTED
400059f0:	c2 07 61 78 	ld  [ %i5 + 0x178 ], %g1	! 4003a578 <_impure_ptr><== NOT EXECUTED
400059f4:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
400059f8:	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);                                          
400059fc:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            <== NOT EXECUTED
    fprintf (stdout, "fdisk:");                                       
40005a00:	94 10 20 06 	mov  6, %o2                                    <== NOT EXECUTED
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
40005a04:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
    fprintf (stdout, "fdisk:");                                       
40005a08:	11 10 00 d4 	sethi  %hi(0x40035000), %o0                    <== NOT EXECUTED
40005a0c:	40 00 7c 47 	call  40024b28 <fwrite>                        <== NOT EXECUTED
40005a10:	90 12 23 80 	or  %o0, 0x380, %o0	! 40035380 <Callbacks.6428+0x138><== NOT EXECUTED
    ret =  vfprintf (stdout, format, args);                           
40005a14:	c2 07 61 78 	ld  [ %i5 + 0x178 ], %g1                       <== NOT EXECUTED
40005a18:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
40005a1c:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
40005a20:	40 00 9d a7 	call  4002d0bc <vfprintf>                      <== NOT EXECUTED
40005a24:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
40005a28:	c2 07 61 78 	ld  [ %i5 + 0x178 ], %g1                       <== NOT EXECUTED
  if (fd->info_level >= 2)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:");                                       
    ret =  vfprintf (stdout, format, args);                           
40005a2c:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
40005a30:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
40005a34:	40 00 7a 5c 	call  400243a4 <fputc>                         <== NOT EXECUTED
40005a38:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
    fflush (stdout);                                                  
40005a3c:	c2 07 61 78 	ld  [ %i5 + 0x178 ], %g1                       <== NOT EXECUTED
40005a40:	40 00 79 41 	call  40023f44 <fflush>                        <== NOT EXECUTED
40005a44:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
    va_end (args);                                                    
  }                                                                   
  return ret;                                                         
}                                                                     
40005a48:	81 c7 e0 08 	ret                                            
40005a4c:	81 e8 00 00 	restore                                        
                                                                      

4000824c <rtems_fdisk_initialize>: */ rtems_device_driver rtems_fdisk_initialize (rtems_device_major_number major, rtems_device_minor_number minor, void* arg __attribute__((unused))) {
4000824c:	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 ();                                   
40008250:	7f ff f5 05 	call  40005664 <rtems_disk_io_initialize>      
40008254:	a4 10 00 18 	mov  %i0, %l2                                  
  if (sc != RTEMS_SUCCESSFUL)                                         
40008258:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000825c:	02 80 00 04 	be  4000826c <rtems_fdisk_initialize+0x20>     <== ALWAYS TAKEN
40008260:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  rtems_flashdisk_count = rtems_flashdisk_configuration_size;         
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40008264:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40008268:	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);        
4000826c:	40 00 05 4c 	call  4000979c <malloc>                        
40008270:	90 10 22 00 	mov  0x200, %o0                                
40008274:	03 10 01 2a 	sethi  %hi(0x4004a800), %g1                    
40008278:	d0 20 63 78 	st  %o0, [ %g1 + 0x378 ]	! 4004ab78 <rtems_fdisk_crc16_factor>
  if (!rtems_fdisk_crc16_factor)                                      
4000827c:	80 a2 20 00 	cmp  %o0, 0                                    
40008280:	02 bf ff f9 	be  40008264 <rtems_fdisk_initialize+0x18>     <== NEVER TAKEN
40008284:	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;                        
40008288:	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)                                      
4000828c:	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;                        
40008290:	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;                                                   
40008294:	82 10 00 03 	mov  %g3, %g1                                  
40008298:	84 10 20 08 	mov  8, %g2                                    
    for (i = 8; i--;)                                                 
      v = v & 1 ? (v >> 1) ^ pattern : v >> 1;                        
4000829c:	80 88 60 01 	btst  1, %g1                                   
400082a0:	83 28 60 10 	sll  %g1, 0x10, %g1                            
400082a4:	02 80 00 03 	be  400082b0 <rtems_fdisk_initialize+0x64>     
400082a8:	83 30 60 11 	srl  %g1, 0x11, %g1                            
400082ac:	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--;)                                                 
400082b0:	84 80 bf ff 	addcc  %g2, -1, %g2                            
400082b4:	12 bf ff fb 	bne  400082a0 <rtems_fdisk_initialize+0x54>    
400082b8:	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,              
400082bc:	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++)                                           
400082c0:	86 00 e0 01 	inc  %g3                                       
400082c4:	80 a0 e1 00 	cmp  %g3, 0x100                                
400082c8:	12 bf ff f3 	bne  40008294 <rtems_fdisk_initialize+0x48>    
400082cc:	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,      
400082d0:	03 10 00 e8 	sethi  %hi(0x4003a000), %g1                    
400082d4:	fa 00 63 bc 	ld  [ %g1 + 0x3bc ], %i5	! 4003a3bc <rtems_flashdisk_configuration_size>
400082d8:	92 10 20 74 	mov  0x74, %o1                                 
400082dc:	90 10 00 1d 	mov  %i5, %o0                                  
400082e0:	40 00 03 2f 	call  40008f9c <calloc>                        
400082e4:	35 10 01 2a 	sethi  %hi(0x4004a800), %i2                    
400082e8:	d0 26 a3 70 	st  %o0, [ %i2 + 0x370 ]	! 4004ab70 <rtems_flashdisks>
                             sizeof (rtems_flashdisk));               
                                                                      
  if (!rtems_flashdisks)                                              
400082ec:	80 a2 20 00 	cmp  %o0, 0                                    
400082f0:	02 bf ff dd 	be  40008264 <rtems_fdisk_initialize+0x18>     <== NEVER TAKEN
400082f4:	b0 10 20 1a 	mov  0x1a, %i0                                 
    return RTEMS_NO_MEMORY;                                           
                                                                      
  for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
400082f8:	80 a7 60 00 	cmp  %i5, 0                                    
400082fc:	02 80 00 f6 	be  400086d4 <rtems_fdisk_initialize+0x488>    <== NEVER TAKEN
40008300:	21 10 00 d3 	sethi  %hi(0x40034c00), %l0                    
40008304:	a6 10 20 00 	clr  %l3                                       
40008308:	a0 14 21 50 	or  %l0, 0x150, %l0                            
4000830c:	a2 10 20 00 	clr  %l1                                       
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
                                                                      
    fd->major              = major;                                   
    fd->minor              = minor;                                   
    fd->flags              = c->flags;                                
40008310:	f8 04 20 0c 	ld  [ %l0 + 0xc ], %i4                         
    fd->compact_segs       = c->compact_segs;                         
40008314:	c8 04 20 14 	ld  [ %l0 + 0x14 ], %g4                        
    fd->avail_compact_segs = c->avail_compact_segs;                   
40008318:	c6 04 20 18 	ld  [ %l0 + 0x18 ], %g3                        
    fd->block_size         = c->block_size;                           
4000831c:	fa 04 00 00 	ld  [ %l0 ], %i5                               
    fd->unavail_blocks     = c->unavail_blocks;                       
40008320:	c4 04 20 10 	ld  [ %l0 + 0x10 ], %g2                        
    fd->info_level         = c->info_level;                           
40008324:	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";           
40008328:	35 00 00 18 	sethi  %hi(0x6000), %i2                        
4000832c:	b4 16 a1 00 	or  %i2, 0x100, %i2	! 6100 <PROM_START+0x6100> 
40008330:	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++)              
40008334:	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;         
40008338:	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";           
4000833c:	35 0b d9 19 	sethi  %hi(0x2f646400), %i2                    
40008340:	37 0b d9 99 	sethi  %hi(0x2f666400), %i3                    
40008344:	b4 16 a1 76 	or  %i2, 0x176, %i2                            
40008348:	b6 16 e0 64 	or  %i3, 0x64, %i3                             
4000834c:	f4 3f bf f0 	std  %i2, [ %fp + -16 ]                        
                                                                      
    fd = &rtems_flashdisks[minor];                                    
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
                                                                      
    fd->major              = major;                                   
40008350:	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];                                    
40008354:	b6 02 00 13 	add  %o0, %l3, %i3                             
                                                                      
    name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;         
                                                                      
    fd->major              = major;                                   
    fd->minor              = minor;                                   
40008358:	e2 26 e0 04 	st  %l1, [ %i3 + 4 ]                           
    fd->flags              = c->flags;                                
4000835c:	f8 26 e0 08 	st  %i4, [ %i3 + 8 ]                           
    fd->compact_segs       = c->compact_segs;                         
40008360:	c8 26 e0 0c 	st  %g4, [ %i3 + 0xc ]                         
    fd->avail_compact_segs = c->avail_compact_segs;                   
40008364:	c6 26 e0 10 	st  %g3, [ %i3 + 0x10 ]                        
    fd->block_size         = c->block_size;                           
40008368:	fa 26 e0 14 	st  %i5, [ %i3 + 0x14 ]                        
    fd->unavail_blocks     = c->unavail_blocks;                       
4000836c:	c4 26 e0 20 	st  %g2, [ %i3 + 0x20 ]                        
    fd->info_level         = c->info_level;                           
                                                                      
    for (device = 0; device < c->device_count; device++)              
40008370:	80 a5 20 00 	cmp  %l4, 0                                    
40008374:	02 80 00 a3 	be  40008600 <rtems_fdisk_initialize+0x3b4>    <== NEVER TAKEN
40008378:	c2 26 e0 6c 	st  %g1, [ %i3 + 0x6c ]                        
4000837c:	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,              
40008380:	83 2d 20 02 	sll  %l4, 2, %g1                               
40008384:	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;                                              
40008388:	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,              
4000838c:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40008390:	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++)                             
40008394:	c4 06 80 00 	ld  [ %i2 ], %g2                               
40008398:	80 a0 a0 00 	cmp  %g2, 0                                    
4000839c:	02 80 00 93 	be  400085e8 <rtems_fdisk_initialize+0x39c>    <== NEVER TAKEN
400083a0:	87 28 a0 02 	sll  %g2, 2, %g3                               
400083a4:	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,              
400083a8:	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;                                                 
400083ac:	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,              
400083b0:	b8 27 00 03 	sub  %i4, %g3, %i4                             
400083b4:	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;                                        
400083b8:	d0 05 60 08 	ld  [ %l5 + 8 ], %o0                           
400083bc:	7f ff e8 b9 	call  400026a0 <.udiv>                         
400083c0:	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;                               
400083c4:	92 10 00 1d 	mov  %i5, %o1                                  
400083c8:	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);            
400083cc:	91 2a 20 03 	sll  %o0, 3, %o0                               
  return ((bytes - 1) / page_size) + 1;                               
400083d0:	7f ff e8 b4 	call  400026a0 <.udiv>                         
400083d4:	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;      
400083d8:	d2 15 40 00 	lduh  [ %l5 ], %o1                             
400083dc:	7f ff e8 77 	call  400025b8 <.umul>                         
400083e0:	90 25 80 08 	sub  %l6, %o0, %o0                             
400083e4:	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++)                             
400083e8:	80 a5 40 1c 	cmp  %l5, %i4                                  
400083ec:	12 bf ff f3 	bne  400083b8 <rtems_fdisk_initialize+0x16c>   <== NEVER TAKEN
400083f0:	ae 05 c0 08 	add  %l7, %o0, %l7                             
400083f4:	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++)              
400083f8:	80 a6 80 18 	cmp  %i2, %i0                                  
400083fc:	12 bf ff e6 	bne  40008394 <rtems_fdisk_initialize+0x148>   <== NEVER TAKEN
40008400:	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);                         
40008404:	40 00 04 e6 	call  4000979c <malloc>                        
40008408:	90 10 00 1d 	mov  %i5, %o0                                  
    if (!fd->copy_buffer)                                             
4000840c:	80 a2 20 00 	cmp  %o0, 0                                    
40008410:	02 80 00 af 	be  400086cc <rtems_fdisk_initialize+0x480>    <== NEVER TAKEN
40008414:	d0 26 e0 68 	st  %o0, [ %i3 + 0x68 ]                        
      return RTEMS_NO_MEMORY;                                         
                                                                      
    fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));     
40008418:	90 10 00 19 	mov  %i1, %o0                                  
4000841c:	40 00 02 e0 	call  40008f9c <calloc>                        
40008420:	92 10 20 08 	mov  8, %o1                                    
    if (!fd->blocks)                                                  
40008424:	80 a2 20 00 	cmp  %o0, 0                                    
40008428:	02 80 00 a9 	be  400086cc <rtems_fdisk_initialize+0x480>    <== NEVER TAKEN
4000842c:	d0 26 e0 18 	st  %o0, [ %i3 + 0x18 ]                        
      return RTEMS_NO_MEMORY;                                         
                                                                      
    fd->block_count = blocks;                                         
40008430:	f2 26 e0 1c 	st  %i1, [ %i3 + 0x1c ]                        
                                                                      
    fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
40008434:	90 10 00 14 	mov  %l4, %o0                                  
40008438:	40 00 02 d9 	call  40008f9c <calloc>                        
4000843c:	92 10 20 0c 	mov  0xc, %o1                                  
    if (!fd->devices)                                                 
40008440:	80 a2 20 00 	cmp  %o0, 0                                    
40008444:	02 80 00 a2 	be  400086cc <rtems_fdisk_initialize+0x480>    <== NEVER TAKEN
40008448:	d0 26 e0 2c 	st  %o0, [ %i3 + 0x2c ]                        
      return RTEMS_NO_MEMORY;                                         
                                                                      
    sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
4000844c:	03 10 00 d7 	sethi  %hi(0x40035c00), %g1                    
40008450:	d0 00 63 28 	ld  [ %g1 + 0x328 ], %o0	! 40035f28 <Callbacks.6428+0xce0>
40008454:	92 10 20 01 	mov  1, %o1                                    
40008458:	94 10 20 54 	mov  0x54, %o2                                 
4000845c:	96 10 20 00 	clr  %o3                                       
40008460:	40 00 15 fa 	call  4000dc48 <rtems_semaphore_create>        
40008464:	98 06 e0 64 	add  %i3, 0x64, %o4                            
                                 RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
                                 RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
    if (sc != RTEMS_SUCCESSFUL)                                       
40008468:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000846c:	12 80 00 8d 	bne  400086a0 <rtems_fdisk_initialize+0x454>   <== NEVER TAKEN
40008470:	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,                   
40008474:	d6 06 e0 20 	ld  [ %i3 + 0x20 ], %o3                        
40008478:	d4 04 00 00 	ld  [ %l0 ], %o2                               
4000847c:	90 10 00 12 	mov  %l2, %o0                                  
40008480:	f4 23 a0 5c 	st  %i2, [ %sp + 0x5c ]                        
40008484:	92 10 00 11 	mov  %l1, %o1                                  
40008488:	96 26 40 0b 	sub  %i1, %o3, %o3                             
4000848c:	19 10 00 1b 	sethi  %hi(0x40006c00), %o4                    
40008490:	9a 10 20 00 	clr  %o5                                       
40008494:	7f ff f3 d4 	call  400053e4 <rtems_disk_create_phys>        
40008498:	98 13 22 34 	or  %o4, 0x234, %o4                            
                                blocks - fd->unavail_blocks,          
                                rtems_fdisk_ioctl, NULL, name);       
    if (sc != RTEMS_SUCCESSFUL)                                       
4000849c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400084a0:	12 80 00 70 	bne  40008660 <rtems_fdisk_initialize+0x414>   <== NEVER TAKEN
400084a4:	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++)              
400084a8:	f0 04 20 04 	ld  [ %l0 + 4 ], %i0                           
400084ac:	80 a6 20 00 	cmp  %i0, 0                                    
400084b0:	22 80 00 3b 	be,a   4000859c <rtems_fdisk_initialize+0x350> <== NEVER TAKEN
400084b4:	f0 26 e0 30 	st  %i0, [ %i3 + 0x30 ]                        <== NOT EXECUTED
400084b8:	f4 04 20 08 	ld  [ %l0 + 8 ], %i2                           
400084bc:	f2 06 e0 2c 	ld  [ %i3 + 0x2c ], %i1                        
400084c0:	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++)           
400084c4:	c4 06 80 00 	ld  [ %i2 ], %g2                               
400084c8:	80 a0 a0 00 	cmp  %g2, 0                                    
400084cc:	02 80 00 5d 	be  40008640 <rtems_fdisk_initialize+0x3f4>    <== NEVER TAKEN
400084d0:	a9 28 a0 02 	sll  %g2, 2, %l4                               
400084d4:	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;                                                 
400084d8:	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,              
400084dc:	85 28 a0 04 	sll  %g2, 4, %g2                               
400084e0:	88 20 80 14 	sub  %g2, %l4, %g4                             
400084e4:	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;                             
400084e8:	c6 10 40 00 	lduh  [ %g1 ], %g3                             
400084ec:	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++)           
400084f0:	80 a0 40 04 	cmp  %g1, %g4                                  
400084f4:	12 bf ff fd 	bne  400084e8 <rtems_fdisk_initialize+0x29c>   <== NEVER TAKEN
400084f8:	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,           
400084fc:	c4 27 bf ec 	st  %g2, [ %fp + -20 ]                         
40008500:	90 10 00 1c 	mov  %i4, %o0                                  
40008504:	40 00 02 a6 	call  40008f9c <calloc>                        
40008508:	92 10 20 30 	mov  0x30, %o1                                 
4000850c:	d0 26 40 00 	st  %o0, [ %i1 ]                               
                                             sizeof (rtems_fdisk_segment_ctl));
      if (!fd->devices[device].segments)                              
40008510:	80 a2 20 00 	cmp  %o0, 0                                    
40008514:	02 80 00 3d 	be  40008608 <rtems_fdisk_initialize+0x3bc>    <== NEVER TAKEN
40008518:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
4000851c:	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,              
40008520:	84 20 80 14 	sub  %g2, %l4, %g2                             
40008524:	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++)
40008528:	c8 10 c0 00 	lduh  [ %g3 ], %g4                             
4000852c:	80 a1 20 00 	cmp  %g4, 0                                    
40008530:	02 80 00 0f 	be  4000856c <rtems_fdisk_initialize+0x320>    <== NEVER TAKEN
40008534:	82 10 00 08 	mov  %o0, %g1                                  
40008538:	84 10 20 00 	clr  %g2                                       
        {                                                             
          sc->descriptor = sd;                                        
          sc->device     = device;                                    
          sc->segment    = seg_segment;                               
4000853c:	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;                                        
40008540:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
          sc->device     = device;                                    
40008544:	fa 20 60 08 	st  %i5, [ %g1 + 8 ]                           
          sc->segment    = seg_segment;                               
          sc->erased     = 0;                                         
40008548:	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++)
4000854c:	84 00 a0 01 	inc  %g2                                       
40008550:	80 a0 80 04 	cmp  %g2, %g4                                  
40008554:	0a bf ff fa 	bcs  4000853c <rtems_fdisk_initialize+0x2f0>   
40008558:	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,              
4000855c:	83 29 20 04 	sll  %g4, 4, %g1                               
40008560:	89 29 20 06 	sll  %g4, 6, %g4                               
40008564:	88 21 00 01 	sub  %g4, %g1, %g4                             
40008568:	90 02 00 04 	add  %o0, %g4, %o0                             
4000856c:	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++)
40008570:	80 a0 c0 0f 	cmp  %g3, %o7                                  
40008574:	32 bf ff ee 	bne,a   4000852c <rtems_fdisk_initialize+0x2e0><== NEVER TAKEN
40008578:	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];        
4000857c:	f4 26 60 08 	st  %i2, [ %i1 + 8 ]                           
          sc->segment    = seg_segment;                               
          sc->erased     = 0;                                         
        }                                                             
      }                                                               
                                                                      
      fd->devices[device].segment_count = segment_count;              
40008580:	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++)              
40008584:	ba 07 60 01 	inc  %i5                                       
40008588:	b4 06 a0 0c 	add  %i2, 0xc, %i2                             
4000858c:	80 a7 40 18 	cmp  %i5, %i0                                  
40008590:	12 bf ff cd 	bne  400084c4 <rtems_fdisk_initialize+0x278>   <== NEVER TAKEN
40008594:	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;                               
40008598:	f0 26 e0 30 	st  %i0, [ %i3 + 0x30 ]                        
                                                                      
    ret = rtems_fdisk_recover_block_mappings (fd);                    
4000859c:	7f ff f9 31 	call  40006a60 <rtems_fdisk_recover_block_mappings>
400085a0:	90 10 00 1b 	mov  %i3, %o0                                  
    if (ret)                                                          
400085a4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400085a8:	12 80 00 63 	bne  40008734 <rtems_fdisk_initialize+0x4e8>   <== NEVER TAKEN
400085ac:	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);                                   
400085b0:	7f ff f8 76 	call  40006788 <rtems_fdisk_compact>           
400085b4:	90 10 00 1b 	mov  %i3, %o0                                  
    if (ret)                                                          
400085b8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400085bc:	12 80 00 4a 	bne  400086e4 <rtems_fdisk_initialize+0x498>   <== NEVER TAKEN
400085c0:	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++)
400085c4:	37 10 00 e8 	sethi  %hi(0x4003a000), %i3                    
400085c8:	fa 06 e3 bc 	ld  [ %i3 + 0x3bc ], %i5	! 4003a3bc <rtems_flashdisk_configuration_size>
400085cc:	a2 04 60 01 	inc  %l1                                       
400085d0:	80 a7 40 11 	cmp  %i5, %l1                                  
400085d4:	08 80 00 40 	bleu  400086d4 <rtems_fdisk_initialize+0x488>  <== ALWAYS TAKEN
400085d8:	a6 04 e0 74 	add  %l3, 0x74, %l3                            
400085dc:	03 10 01 2a 	sethi  %hi(0x4004a800), %g1                    <== NOT EXECUTED
400085e0:	10 bf ff 4c 	b  40008310 <rtems_fdisk_initialize+0xc4>      <== NOT EXECUTED
400085e4:	d0 00 63 70 	ld  [ %g1 + 0x370 ], %o0	! 4004ab70 <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;                                                 
400085e8:	ae 10 20 00 	clr  %l7                                       <== NOT EXECUTED
400085ec:	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++)              
400085f0:	80 a6 80 18 	cmp  %i2, %i0                                  <== NOT EXECUTED
400085f4:	12 bf ff 68 	bne  40008394 <rtems_fdisk_initialize+0x148>   <== NOT EXECUTED
400085f8:	b2 06 40 17 	add  %i1, %l7, %i1                             <== NOT EXECUTED
400085fc:	30 bf ff 82 	b,a   40008404 <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;                                              
40008600:	10 bf ff 81 	b  40008404 <rtems_fdisk_initialize+0x1b8>     <== NOT EXECUTED
40008604:	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);                                      
40008608:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4000860c:	7f ff f2 c5 	call  40005120 <rtems_disk_delete>             <== NOT EXECUTED
40008610:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
        rtems_semaphore_delete (fd->lock);                            
40008614:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
40008618:	40 00 15 fd 	call  4000de0c <rtems_semaphore_delete>        <== NOT EXECUTED
4000861c:	b0 10 20 1a 	mov  0x1a, %i0                                 <== NOT EXECUTED
        free (fd->copy_buffer);                                       
40008620:	40 00 02 c2 	call  40009128 <free>                          <== NOT EXECUTED
40008624:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
        free (fd->blocks);                                            
40008628:	40 00 02 c0 	call  40009128 <free>                          <== NOT EXECUTED
4000862c:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
        free (fd->devices);                                           
40008630:	40 00 02 be 	call  40009128 <free>                          <== NOT EXECUTED
40008634:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
40008638:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000863c:	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,           
40008640:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40008644:	40 00 02 56 	call  40008f9c <calloc>                        <== NOT EXECUTED
40008648:	92 10 20 30 	mov  0x30, %o1                                 <== NOT EXECUTED
                                             sizeof (rtems_fdisk_segment_ctl));
      if (!fd->devices[device].segments)                              
4000864c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40008650:	02 bf ff ee 	be  40008608 <rtems_fdisk_initialize+0x3bc>    <== NOT EXECUTED
40008654:	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;                                                 
40008658:	10 bf ff c9 	b  4000857c <rtems_fdisk_initialize+0x330>     <== NOT EXECUTED
4000865c:	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);                              
40008660:	40 00 15 eb 	call  4000de0c <rtems_semaphore_delete>        <== NOT EXECUTED
40008664:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
      rtems_disk_delete (dev);                                        
40008668:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4000866c:	7f ff f2 ad 	call  40005120 <rtems_disk_delete>             <== NOT EXECUTED
40008670:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
      free (fd->copy_buffer);                                         
40008674:	40 00 02 ad 	call  40009128 <free>                          <== NOT EXECUTED
40008678:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
4000867c:	40 00 02 ab 	call  40009128 <free>                          <== NOT EXECUTED
40008680:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
40008684:	40 00 02 a9 	call  40009128 <free>                          <== NOT EXECUTED
40008688:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
      rtems_fdisk_error ("disk create phy failed");                   
4000868c:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40008690:	7f ff f5 ca 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40008694:	90 12 22 c0 	or  %o0, 0x2c0, %o0	! 40035ec0 <Callbacks.6428+0xc78><== NOT EXECUTED
40008698:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000869c:	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");                  
400086a0:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
400086a4:	7f ff f5 c5 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
400086a8:	90 12 22 a8 	or  %o0, 0x2a8, %o0	! 40035ea8 <Callbacks.6428+0xc60><== NOT EXECUTED
      free (fd->copy_buffer);                                         
400086ac:	40 00 02 9f 	call  40009128 <free>                          <== NOT EXECUTED
400086b0:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
400086b4:	40 00 02 9d 	call  40009128 <free>                          <== NOT EXECUTED
400086b8:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
400086bc:	40 00 02 9b 	call  40009128 <free>                          <== NOT EXECUTED
400086c0:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
400086c4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400086c8:	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;                                         
400086cc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400086d0:	91 e8 20 1a 	restore  %g0, 0x1a, %o0                        <== NOT EXECUTED
                         strerror (ret), ret);                        
      return ret;                                                     
    }                                                                 
  }                                                                   
                                                                      
  rtems_flashdisk_count = rtems_flashdisk_configuration_size;         
400086d4:	03 10 01 2a 	sethi  %hi(0x4004a800), %g1                    
400086d8:	fa 20 63 74 	st  %i5, [ %g1 + 0x374 ]	! 4004ab74 <rtems_flashdisk_count>
                                                                      
  return RTEMS_SUCCESSFUL;                                            
400086dc:	81 c7 e0 08 	ret                                            
400086e0:	91 e8 20 00 	restore  %g0, 0, %o0                           
    }                                                                 
                                                                      
    ret = rtems_fdisk_compact (fd);                                   
    if (ret)                                                          
    {                                                                 
      rtems_disk_delete (dev);                                        
400086e4:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
400086e8:	7f ff f2 8e 	call  40005120 <rtems_disk_delete>             <== NOT EXECUTED
400086ec:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
      rtems_semaphore_delete (fd->lock);                              
400086f0:	40 00 15 c7 	call  4000de0c <rtems_semaphore_delete>        <== NOT EXECUTED
400086f4:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
      free (fd->copy_buffer);                                         
400086f8:	40 00 02 8c 	call  40009128 <free>                          <== NOT EXECUTED
400086fc:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
40008700:	40 00 02 8a 	call  40009128 <free>                          <== NOT EXECUTED
40008704:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
40008708:	40 00 02 88 	call  40009128 <free>                          <== NOT EXECUTED
4000870c:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
      rtems_fdisk_error ("compacting of disk failed: %s (%d)",        
40008710:	40 00 76 e5 	call  400262a4 <strerror>                      <== NOT EXECUTED
40008714:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40008718:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
4000871c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40008720:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40008724:	7f ff f5 a5 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40008728:	90 12 23 00 	or  %o0, 0x300, %o0	! 40035f00 <Callbacks.6428+0xcb8><== NOT EXECUTED
4000872c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40008730:	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);                                        
40008734:	7f ff f2 7b 	call  40005120 <rtems_disk_delete>             <== NOT EXECUTED
40008738:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
      rtems_semaphore_delete (fd->lock);                              
4000873c:	40 00 15 b4 	call  4000de0c <rtems_semaphore_delete>        <== NOT EXECUTED
40008740:	d0 06 e0 64 	ld  [ %i3 + 0x64 ], %o0                        <== NOT EXECUTED
      free (fd->copy_buffer);                                         
40008744:	40 00 02 79 	call  40009128 <free>                          <== NOT EXECUTED
40008748:	d0 06 e0 68 	ld  [ %i3 + 0x68 ], %o0                        <== NOT EXECUTED
      free (fd->blocks);                                              
4000874c:	40 00 02 77 	call  40009128 <free>                          <== NOT EXECUTED
40008750:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        <== NOT EXECUTED
      free (fd->devices);                                             
40008754:	40 00 02 75 	call  40009128 <free>                          <== NOT EXECUTED
40008758:	d0 06 e0 2c 	ld  [ %i3 + 0x2c ], %o0                        <== NOT EXECUTED
      rtems_fdisk_error ("recovery of disk failed: %s (%d)",          
4000875c:	40 00 76 d2 	call  400262a4 <strerror>                      <== NOT EXECUTED
40008760:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40008764:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
40008768:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4000876c:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40008770:	7f ff f5 92 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40008774:	90 12 22 d8 	or  %o0, 0x2d8, %o0	! 40035ed8 <Callbacks.6428+0xc90><== NOT EXECUTED
40008778:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000877c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40006e34 <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) {
40006e34:	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;                                                          
40006e38:	40 00 73 40 	call  40023b38 <__errno>                       
40006e3c:	fa 06 20 04 	ld  [ %i0 + 4 ], %i5                           
                                                                      
  sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40006e40:	21 10 01 2a 	sethi  %hi(0x4004a800), %l0                    
40006e44:	c2 04 23 70 	ld  [ %l0 + 0x370 ], %g1	! 4004ab70 <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;                                                          
40006e48:	c0 22 00 00 	clr  [ %o0 ]                                   
                                                                      
  sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
40006e4c:	87 2f 60 05 	sll  %i5, 5, %g3                               
40006e50:	85 2f 60 02 	sll  %i5, 2, %g2                               
40006e54:	84 20 c0 02 	sub  %g3, %g2, %g2                             
40006e58:	84 00 80 1d 	add  %g2, %i5, %g2                             
40006e5c:	ab 28 a0 02 	sll  %g2, 2, %l5                               
40006e60:	82 00 40 15 	add  %g1, %l5, %g1                             
40006e64:	d0 00 60 64 	ld  [ %g1 + 0x64 ], %o0                        
40006e68:	92 10 20 00 	clr  %o1                                       
40006e6c:	40 00 1c 1f 	call  4000dee8 <rtems_semaphore_obtain>        
40006e70:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
40006e74:	80 a2 20 00 	cmp  %o0, 0                                    
40006e78:	12 80 00 36 	bne  40006f50 <rtems_fdisk_ioctl+0x11c>        <== NEVER TAKEN
40006e7c:	01 00 00 00 	nop                                            
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
40006e80:	40 00 73 2e 	call  40023b38 <__errno>                       
40006e84:	01 00 00 00 	nop                                            
    switch (req)                                                      
40006e88:	03 08 00 10 	sethi  %hi(0x20004000), %g1                    
40006e8c:	84 10 62 83 	or  %g1, 0x283, %g2	! 20004283 <RAM_SIZE+0x1fc04283>
40006e90:	80 a6 40 02 	cmp  %i1, %g2                                  
40006e94:	02 80 00 5b 	be  40007000 <rtems_fdisk_ioctl+0x1cc>         <== NEVER TAKEN
40006e98:	c0 22 00 00 	clr  [ %o0 ]                                   
40006e9c:	80 a6 40 02 	cmp  %i1, %g2                                  
40006ea0:	38 80 00 37 	bgu,a   40006f7c <rtems_fdisk_ioctl+0x148>     
40006ea4:	82 10 62 85 	or  %g1, 0x285, %g1                            
40006ea8:	84 10 62 81 	or  %g1, 0x281, %g2                            
40006eac:	80 a6 40 02 	cmp  %i1, %g2                                  
40006eb0:	02 80 00 de 	be  40007228 <rtems_fdisk_ioctl+0x3f4>         <== NEVER TAKEN
40006eb4:	01 00 00 00 	nop                                            
40006eb8:	08 80 00 d0 	bleu  400071f8 <rtems_fdisk_ioctl+0x3c4>       <== ALWAYS TAKEN
40006ebc:	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]);    
40006ec0:	40 00 73 1e 	call  40023b38 <__errno>                       <== NOT EXECUTED
40006ec4:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
40006ec8:	fa 04 23 70 	ld  [ %l0 + 0x370 ], %i5                       <== NOT EXECUTED
40006ecc:	b6 10 00 08 	mov  %o0, %i3                                  <== NOT EXECUTED
40006ed0:	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)                                                    
40006ed4:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        <== NOT EXECUTED
40006ed8:	92 90 60 00 	orcc  %g1, 0, %o1                              <== NOT EXECUTED
40006edc:	02 80 00 15 	be  40006f30 <rtems_fdisk_ioctl+0xfc>          <== NOT EXECUTED
40006ee0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
40006ee4:	c4 00 40 00 	ld  [ %g1 ], %g2                               <== NOT EXECUTED
    if (!queue->head)                                                 
40006ee8:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40006eec:	02 80 01 09 	be  40007310 <rtems_fdisk_ioctl+0x4dc>         <== NOT EXECUTED
40006ef0:	c4 27 60 4c 	st  %g2, [ %i5 + 0x4c ]                        <== NOT EXECUTED
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
40006ef4:	c4 07 60 54 	ld  [ %i5 + 0x54 ], %g2                        <== NOT EXECUTED
40006ef8:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
40006efc:	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);                     
40006f00:	7f ff fb cd 	call  40005e34 <rtems_fdisk_erase_segment>     <== NOT EXECUTED
40006f04:	c0 20 40 00 	clr  [ %g1 ]                                   <== NOT EXECUTED
    if (ret && !latched_ret)                                          
40006f08:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40006f0c:	02 bf ff f3 	be  40006ed8 <rtems_fdisk_ioctl+0xa4>          <== NOT EXECUTED
40006f10:	c2 07 60 4c 	ld  [ %i5 + 0x4c ], %g1                        <== NOT EXECUTED
40006f14:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40006f18:	12 bf ff f0 	bne  40006ed8 <rtems_fdisk_ioctl+0xa4>         <== NOT EXECUTED
40006f1c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006f20:	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)                                                    
40006f24:	92 90 60 00 	orcc  %g1, 0, %o1                              <== NOT EXECUTED
40006f28:	12 bf ff ef 	bne  40006ee4 <rtems_fdisk_ioctl+0xb0>         <== NOT EXECUTED
40006f2c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40006f30:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %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]);    
40006f34:	f8 26 c0 00 	st  %i4, [ %i3 ]                               <== NOT EXECUTED
40006f38:	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);      
40006f3c:	40 00 1c 3a 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
40006f40:	d0 00 a0 64 	ld  [ %g2 + 0x64 ], %o0                        <== NOT EXECUTED
    if (sc != RTEMS_SUCCESSFUL)                                       
40006f44:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40006f48:	02 80 00 06 	be  40006f60 <rtems_fdisk_ioctl+0x12c>         <== NOT EXECUTED
40006f4c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      errno = EIO;                                                    
40006f50:	40 00 72 fa 	call  40023b38 <__errno>                       <== NOT EXECUTED
40006f54:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006f58:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               <== NOT EXECUTED
40006f5c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return errno == 0 ? 0 : -1;                                         
40006f60:	40 00 72 f6 	call  40023b38 <__errno>                       <== NOT EXECUTED
40006f64:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006f68:	c2 02 00 00 	ld  [ %o0 ], %g1                               <== NOT EXECUTED
40006f6c:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
40006f70:	b0 60 20 00 	subx  %g0, 0, %i0                              <== NOT EXECUTED
40006f74:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006f78:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
    switch (req)                                                      
40006f7c:	80 a6 40 01 	cmp  %i1, %g1                                  
40006f80:	02 80 00 e6 	be  40007318 <rtems_fdisk_ioctl+0x4e4>         
40006f84:	01 00 00 00 	nop                                            
40006f88:	0a 80 00 a5 	bcs  4000721c <rtems_fdisk_ioctl+0x3e8>        <== NEVER TAKEN
40006f8c:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       
40006f90:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
40006f94:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <LEON_REG+0x40184201>
40006f98:	80 a6 40 01 	cmp  %i1, %g1                                  
40006f9c:	12 80 00 9a 	bne  40007204 <rtems_fdisk_ioctl+0x3d0>        
40006fa0:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        if ((minor >= rtems_flashdisk_count) ||                       
40006fa4:	03 10 01 2a 	sethi  %hi(0x4004a800), %g1                    
40006fa8:	c2 00 63 74 	ld  [ %g1 + 0x374 ], %g1	! 4004ab74 <rtems_flashdisk_count>
40006fac:	80 a0 40 1d 	cmp  %g1, %i5                                  
40006fb0:	08 80 02 0b 	bleu  400077dc <rtems_fdisk_ioctl+0x9a8>       <== NEVER TAKEN
40006fb4:	c2 04 23 70 	ld  [ %l0 + 0x370 ], %g1                       
            (rtems_flashdisks[minor].device_count == 0))              
40006fb8:	82 00 40 15 	add  %g1, %l5, %g1                             
  {                                                                   
    errno = 0;                                                        
    switch (req)                                                      
    {                                                                 
      case RTEMS_BLKIO_REQUEST:                                       
        if ((minor >= rtems_flashdisk_count) ||                       
40006fbc:	c2 00 60 30 	ld  [ %g1 + 0x30 ], %g1                        
40006fc0:	80 a0 60 00 	cmp  %g1, 0                                    
40006fc4:	02 80 02 06 	be  400077dc <rtems_fdisk_ioctl+0x9a8>         <== NEVER TAKEN
40006fc8:	01 00 00 00 	nop                                            
        {                                                             
          errno = ENODEV;                                             
        }                                                             
        else                                                          
        {                                                             
          switch (r->req)                                             
40006fcc:	c2 06 80 00 	ld  [ %i2 ], %g1                               
40006fd0:	80 a0 60 00 	cmp  %g1, 0                                    
40006fd4:	02 80 03 b0 	be  40007e94 <rtems_fdisk_ioctl+0x1060>        
40006fd8:	80 a0 60 01 	cmp  %g1, 1                                    
40006fdc:	02 80 02 09 	be  40007800 <rtems_fdisk_ioctl+0x9cc>         <== ALWAYS TAKEN
40006fe0:	01 00 00 00 	nop                                            
            case RTEMS_BLKDEV_REQ_WRITE:                              
              errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
              break;                                                  
                                                                      
            default:                                                  
              errno = EINVAL;                                         
40006fe4:	40 00 72 d5 	call  40023b38 <__errno>                       <== NOT EXECUTED
40006fe8:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006fec:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       <== NOT EXECUTED
40006ff0:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40006ff4:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
              break;                                                  
40006ff8:	10 80 00 74 	b  400071c8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
40006ffc:	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],
40007000:	40 00 72 ce 	call  40023b38 <__errno>                       <== NOT EXECUTED
40007004:	01 00 00 00 	nop                                            <== NOT EXECUTED
40007008:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       <== NOT EXECUTED
4000700c:	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;                             
40007010:	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;                              
40007014:	fa 00 a0 14 	ld  [ %g2 + 0x14 ], %i5                        <== NOT EXECUTED
  data->block_count    = fd->block_count;                             
  data->unavail_blocks = fd->unavail_blocks;                          
40007018:	c8 00 a0 20 	ld  [ %g2 + 0x20 ], %g4                        <== NOT EXECUTED
  data->device_count   = fd->device_count;                            
4000701c:	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;                              
40007020:	fa 26 80 00 	st  %i5, [ %i2 ]                               <== NOT EXECUTED
  data->block_count    = fd->block_count;                             
40007024:	c6 26 a0 04 	st  %g3, [ %i2 + 4 ]                           <== NOT EXECUTED
  data->unavail_blocks = fd->unavail_blocks;                          
40007028:	c8 26 a0 08 	st  %g4, [ %i2 + 8 ]                           <== NOT EXECUTED
  data->device_count   = fd->device_count;                            
4000702c:	c2 26 a0 0c 	st  %g1, [ %i2 + 0xc ]                         <== NOT EXECUTED
                                                                      
  data->blocks_used = 0;                                              
  for (i = 0; i < fd->block_count; i++)                               
40007030:	80 a0 e0 00 	cmp  %g3, 0                                    <== NOT EXECUTED
40007034:	02 80 00 0f 	be  40007070 <rtems_fdisk_ioctl+0x23c>         <== NOT EXECUTED
40007038:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            <== NOT EXECUTED
4000703c:	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)   
40007040:	89 28 e0 03 	sll  %g3, 3, %g4                               <== NOT EXECUTED
40007044:	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)                                        
40007048:	f8 07 40 03 	ld  [ %i5 + %g3 ], %i4                         <== NOT EXECUTED
4000704c:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40007050:	02 80 00 05 	be  40007064 <rtems_fdisk_ioctl+0x230>         <== NOT EXECUTED
40007054:	86 00 e0 08 	add  %g3, 8, %g3                               <== NOT EXECUTED
      data->blocks_used++;                                            
40007058:	f8 06 a0 18 	ld  [ %i2 + 0x18 ], %i4                        <== NOT EXECUTED
4000705c:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
40007060:	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++)                               
40007064:	80 a0 c0 04 	cmp  %g3, %g4                                  <== NOT EXECUTED
40007068:	32 bf ff f9 	bne,a   4000704c <rtems_fdisk_ioctl+0x218>     <== NOT EXECUTED
4000706c:	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;                          
40007070:	c8 00 a0 34 	ld  [ %g2 + 0x34 ], %g4                        <== NOT EXECUTED
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40007074:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40007078:	02 80 00 06 	be  40007090 <rtems_fdisk_ioctl+0x25c>         <== NOT EXECUTED
4000707c:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
40007080:	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)                                                          
40007084:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40007088:	12 bf ff fe 	bne  40007080 <rtems_fdisk_ioctl+0x24c>        <== NOT EXECUTED
4000708c:	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;                          
40007090:	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);
40007094:	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)                                                          
40007098:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
4000709c:	02 80 00 06 	be  400070b4 <rtems_fdisk_ioctl+0x280>         <== NOT EXECUTED
400070a0:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
400070a4:	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)                                                          
400070a8:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
400070ac:	12 bf ff fe 	bne  400070a4 <rtems_fdisk_ioctl+0x270>        <== NOT EXECUTED
400070b0:	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;                          
400070b4:	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); 
400070b8:	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)                                                          
400070bc:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
400070c0:	02 80 00 06 	be  400070d8 <rtems_fdisk_ioctl+0x2a4>         <== NOT EXECUTED
400070c4:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
400070c8:	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)                                                          
400070cc:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
400070d0:	12 bf ff fe 	bne  400070c8 <rtems_fdisk_ioctl+0x294>        <== NOT EXECUTED
400070d4:	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);
400070d8:	c6 26 a0 24 	st  %g3, [ %i2 + 0x24 ]                        <== NOT EXECUTED
                                                                      
  data->segment_count = 0;                                            
400070dc:	c0 26 a0 10 	clr  [ %i2 + 0x10 ]                            <== NOT EXECUTED
  data->page_count    = 0;                                            
400070e0:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            <== NOT EXECUTED
  data->pages_desc    = 0;                                            
400070e4:	c0 26 a0 2c 	clr  [ %i2 + 0x2c ]                            <== NOT EXECUTED
  data->pages_active  = 0;                                            
400070e8:	c0 26 a0 30 	clr  [ %i2 + 0x30 ]                            <== NOT EXECUTED
  data->pages_used    = 0;                                            
400070ec:	c0 26 a0 34 	clr  [ %i2 + 0x34 ]                            <== NOT EXECUTED
  data->pages_bad     = 0;                                            
400070f0:	c0 26 a0 38 	clr  [ %i2 + 0x38 ]                            <== NOT EXECUTED
  data->seg_erases    = 0;                                            
                                                                      
  for (i = 0; i < fd->device_count; i++)                              
400070f4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400070f8:	02 80 00 31 	be  400071bc <rtems_fdisk_ioctl+0x388>         <== NOT EXECUTED
400070fc:	c0 26 a0 28 	clr  [ %i2 + 0x28 ]                            <== NOT EXECUTED
40007100:	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)   
40007104:	87 28 60 02 	sll  %g1, 2, %g3                               <== NOT EXECUTED
40007108:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
4000710c:	83 28 60 04 	sll  %g1, 4, %g1                               <== NOT EXECUTED
40007110:	a4 20 40 03 	sub  %g1, %g3, %l2                             <== NOT EXECUTED
40007114:	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;              
40007118:	f0 04 20 04 	ld  [ %l0 + 4 ], %i0                           <== NOT EXECUTED
                                                                      
    for (j = 0; j < fd->devices[i].segment_count; j++)                
4000711c:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
40007120:	02 80 00 22 	be  400071a8 <rtems_fdisk_ioctl+0x374>         <== NOT EXECUTED
40007124:	a2 04 40 18 	add  %l1, %i0, %l1                             <== NOT EXECUTED
40007128:	c2 04 00 00 	ld  [ %l0 ], %g1                               <== NOT EXECUTED
4000712c:	f2 06 a0 14 	ld  [ %i2 + 0x14 ], %i1                        <== NOT EXECUTED
40007130:	f6 06 a0 2c 	ld  [ %i2 + 0x2c ], %i3                        <== NOT EXECUTED
40007134:	f8 06 a0 30 	ld  [ %i2 + 0x30 ], %i4                        <== NOT EXECUTED
40007138:	fa 06 a0 34 	ld  [ %i2 + 0x34 ], %i5                        <== NOT EXECUTED
4000713c:	c8 06 a0 38 	ld  [ %i2 + 0x38 ], %g4                        <== NOT EXECUTED
40007140:	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)   
40007144:	9f 2e 20 04 	sll  %i0, 4, %o7                               <== NOT EXECUTED
40007148:	b1 2e 20 06 	sll  %i0, 6, %i0                               <== NOT EXECUTED
4000714c:	92 26 00 0f 	sub  %i0, %o7, %o1                             <== NOT EXECUTED
40007150:	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;                                
40007154:	d4 00 60 14 	ld  [ %g1 + 0x14 ], %o2                        <== NOT EXECUTED
      data->pages_desc   += sc->pages_desc;                           
40007158:	d6 00 60 18 	ld  [ %g1 + 0x18 ], %o3                        <== NOT EXECUTED
      data->pages_active += sc->pages_active;                         
4000715c:	d8 00 60 1c 	ld  [ %g1 + 0x1c ], %o4                        <== NOT EXECUTED
      data->pages_used   += sc->pages_used;                           
40007160:	da 00 60 20 	ld  [ %g1 + 0x20 ], %o5                        <== NOT EXECUTED
      data->pages_bad    += sc->pages_bad;                            
40007164:	de 00 60 24 	ld  [ %g1 + 0x24 ], %o7                        <== NOT EXECUTED
      data->seg_erases   += sc->erased;                               
40007168:	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;                                
4000716c:	b2 06 40 0a 	add  %i1, %o2, %i1                             <== NOT EXECUTED
40007170:	82 00 60 30 	add  %g1, 0x30, %g1                            <== NOT EXECUTED
      data->pages_desc   += sc->pages_desc;                           
40007174:	b6 06 c0 0b 	add  %i3, %o3, %i3                             <== NOT EXECUTED
      data->pages_active += sc->pages_active;                         
40007178:	b8 07 00 0c 	add  %i4, %o4, %i4                             <== NOT EXECUTED
      data->pages_used   += sc->pages_used;                           
4000717c:	ba 07 40 0d 	add  %i5, %o5, %i5                             <== NOT EXECUTED
      data->pages_bad    += sc->pages_bad;                            
40007180:	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++)                
40007184:	80 a0 40 09 	cmp  %g1, %o1                                  <== NOT EXECUTED
40007188:	12 bf ff f3 	bne  40007154 <rtems_fdisk_ioctl+0x320>        <== NOT EXECUTED
4000718c:	86 00 c0 18 	add  %g3, %i0, %g3                             <== NOT EXECUTED
40007190:	f2 26 a0 14 	st  %i1, [ %i2 + 0x14 ]                        <== NOT EXECUTED
40007194:	f6 26 a0 2c 	st  %i3, [ %i2 + 0x2c ]                        <== NOT EXECUTED
40007198:	f8 26 a0 30 	st  %i4, [ %i2 + 0x30 ]                        <== NOT EXECUTED
4000719c:	fa 26 a0 34 	st  %i5, [ %i2 + 0x34 ]                        <== NOT EXECUTED
400071a0:	c8 26 a0 38 	st  %g4, [ %i2 + 0x38 ]                        <== NOT EXECUTED
400071a4:	c6 26 a0 28 	st  %g3, [ %i2 + 0x28 ]                        <== NOT EXECUTED
400071a8:	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++)                              
400071ac:	80 a4 00 12 	cmp  %l0, %l2                                  <== NOT EXECUTED
400071b0:	32 bf ff db 	bne,a   4000711c <rtems_fdisk_ioctl+0x2e8>     <== NOT EXECUTED
400071b4:	f0 04 20 04 	ld  [ %l0 + 4 ], %i0                           <== NOT EXECUTED
400071b8:	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;                                  
400071bc:	c2 00 a0 6c 	ld  [ %g2 + 0x6c ], %g1                        <== NOT EXECUTED
400071c0:	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],
400071c4:	c0 22 00 00 	clr  [ %o0 ]                                   <== NOT EXECUTED
      default:                                                        
        rtems_blkdev_ioctl (dd, req, argp);                           
        break;                                                        
    }                                                                 
                                                                      
    sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);      
400071c8:	40 00 1b 97 	call  4000e024 <rtems_semaphore_release>       
400071cc:	d0 00 a0 64 	ld  [ %g2 + 0x64 ], %o0                        
    if (sc != RTEMS_SUCCESSFUL)                                       
400071d0:	80 a2 20 00 	cmp  %o0, 0                                    
400071d4:	12 bf ff 5f 	bne  40006f50 <rtems_fdisk_ioctl+0x11c>        <== NEVER TAKEN
400071d8:	01 00 00 00 	nop                                            
      errno = EIO;                                                    
  }                                                                   
                                                                      
  return errno == 0 ? 0 : -1;                                         
400071dc:	40 00 72 57 	call  40023b38 <__errno>                       
400071e0:	01 00 00 00 	nop                                            
400071e4:	c2 02 00 00 	ld  [ %o0 ], %g1                               
400071e8:	80 a0 00 01 	cmp  %g0, %g1                                  
400071ec:	b0 60 20 00 	subx  %g0, 0, %i0                              
400071f0:	81 c7 e0 08 	ret                                            
400071f4:	81 e8 00 00 	restore                                        
  if (sc != RTEMS_SUCCESSFUL)                                         
    errno = EIO;                                                      
  else                                                                
  {                                                                   
    errno = 0;                                                        
    switch (req)                                                      
400071f8:	80 a6 40 01 	cmp  %i1, %g1                                  
400071fc:	02 80 00 15 	be  40007250 <rtems_fdisk_ioctl+0x41c>         <== NEVER TAKEN
40007200:	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);                           
40007204:	92 10 00 19 	mov  %i1, %o1                                  
40007208:	40 00 42 c8 	call  40017d28 <rtems_blkdev_ioctl>            
4000720c:	94 10 00 1a 	mov  %i2, %o2                                  
40007210:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       
        break;                                                        
40007214:	10 bf ff ed 	b  400071c8 <rtems_fdisk_ioctl+0x394>          
40007218:	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;        
4000721c:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
        break;                                                        
40007220:	10 bf ff ea 	b  400071c8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
40007224:	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]);       
40007228:	40 00 72 44 	call  40023b38 <__errno>                       <== NOT EXECUTED
4000722c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40007230:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
40007234:	d0 04 23 70 	ld  [ %l0 + 0x370 ], %o0                       <== NOT EXECUTED
40007238:	7f ff fd 54 	call  40006788 <rtems_fdisk_compact>           <== NOT EXECUTED
4000723c:	90 02 00 15 	add  %o0, %l5, %o0                             <== NOT EXECUTED
40007240:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       <== NOT EXECUTED
40007244:	d0 27 40 00 	st  %o0, [ %i5 ]                               <== NOT EXECUTED
        break;                                                        
40007248:	10 bf ff e0 	b  400071c8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
4000724c:	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]);    
40007250:	40 00 72 3a 	call  40023b38 <__errno>                       <== NOT EXECUTED
40007254:	01 00 00 00 	nop                                            <== NOT EXECUTED
40007258:	fa 04 23 70 	ld  [ %l0 + 0x370 ], %i5                       <== NOT EXECUTED
4000725c:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
40007260:	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");                                
40007264:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    <== NOT EXECUTED
40007268:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4000726c:	7f ff f9 d7 	call  400059c8 <rtems_fdisk_info>              <== NOT EXECUTED
40007270:	92 12 60 78 	or  %o1, 0x78, %o1                             <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
40007274:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
40007278:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000727c:	02 80 03 e3 	be  40008208 <rtems_fdisk_ioctl+0x13d4>        <== NOT EXECUTED
40007280:	31 10 00 d7 	sethi  %hi(0x40035c00), %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);             
40007284:	33 10 00 d7 	sethi  %hi(0x40035c00), %i1                    <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
40007288:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
4000728c:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  {                                                                   
    int ret;                                                          
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " erase-flash:%02d", device);               
40007290:	b0 16 20 88 	or  %i0, 0x88, %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);             
40007294:	10 80 00 06 	b  400072ac <rtems_fdisk_ioctl+0x478>          <== NOT EXECUTED
40007298:	b2 16 60 a0 	or  %i1, 0xa0, %i1                             <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
4000729c:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
400072a0:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
400072a4:	1a 80 03 be 	bcc  4000819c <rtems_fdisk_ioctl+0x1368>       <== NOT EXECUTED
400072a8:	b6 06 e0 0c 	add  %i3, 0xc, %i3                             <== NOT EXECUTED
  {                                                                   
    int ret;                                                          
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " erase-flash:%02d", device);               
400072ac:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
400072b0:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
400072b4:	7f ff f9 c5 	call  400059c8 <rtems_fdisk_info>              <== NOT EXECUTED
400072b8:	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;                    
400072bc:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        <== NOT EXECUTED
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
400072c0:	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;                    
400072c4:	82 00 40 1b 	add  %g1, %i3, %g1                             <== NOT EXECUTED
400072c8:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           <== NOT EXECUTED
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
400072cc:	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;                    
400072d0:	e2 00 60 08 	ld  [ %g1 + 8 ], %l1                           <== NOT EXECUTED
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_printf (fd, " device-erase: %02d", device);             
400072d4:	7f ff f9 df 	call  40005a50 <rtems_fdisk_printf>            <== NOT EXECUTED
400072d8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
#endif                                                                
  return ops->erase_device (fd->devices[device].descriptor, device);  
400072dc:	c4 07 60 2c 	ld  [ %i5 + 0x2c ], %g2                        <== NOT EXECUTED
400072e0:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        <== NOT EXECUTED
400072e4:	84 00 80 1b 	add  %g2, %i3, %g2                             <== NOT EXECUTED
400072e8:	d0 00 a0 08 	ld  [ %g2 + 8 ], %o0                           <== NOT EXECUTED
400072ec:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400072f0:	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)                                                     
400072f4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400072f8:	22 bf ff e9 	be,a   4000729c <rtems_fdisk_ioctl+0x468>      <== NOT EXECUTED
400072fc:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
40007300:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       <== NOT EXECUTED
          }                                                           
        }                                                             
        break;                                                        
                                                                      
      case RTEMS_FDISK_IOCTL_ERASE_DISK:                              
        errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);    
40007304:	d0 26 80 00 	st  %o0, [ %i2 ]                               <== NOT EXECUTED
        break;                                                        
40007308:	10 bf ff b0 	b  400071c8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
4000730c:	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;                                                
40007310:	10 bf fe f9 	b  40006ef4 <rtems_fdisk_ioctl+0xc0>           <== NOT EXECUTED
40007314:	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]);  
40007318:	40 00 72 08 	call  40023b38 <__errno>                       
4000731c:	ba 10 20 00 	clr  %i5                                       
40007320:	c2 04 23 70 	ld  [ %l0 + 0x370 ], %g1                       
40007324:	d0 27 bf e8 	st  %o0, [ %fp + -24 ]                         
40007328:	b6 00 40 15 	add  %g1, %l5, %i3                             
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
                                                                      
  rtems_fdisk_printf (fd,                                             
4000732c:	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;                       
40007330:	c4 06 e0 6c 	ld  [ %i3 + 0x6c ], %g2                        
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
                                                                      
  rtems_fdisk_printf (fd,                                             
40007334:	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;                                                 
40007338:	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;                       
4000733c:	c4 27 bf e4 	st  %g2, [ %fp + -28 ]                         
  uint32_t total;                                                     
  uint32_t count;                                                     
  uint32_t device;                                                    
                                                                      
  fd->info_level = 3;                                                 
40007340:	c2 26 e0 6c 	st  %g1, [ %i3 + 0x6c ]                        
                                                                      
  rtems_fdisk_printf (fd,                                             
40007344:	90 10 00 1b 	mov  %i3, %o0                                  
40007348:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
4000734c:	7f ff f9 c1 	call  40005a50 <rtems_fdisk_printf>            
40007350:	92 12 60 b8 	or  %o1, 0xb8, %o1	! 40035cb8 <Callbacks.6428+0xa70>
                      "Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
                                                                      
  rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);        
40007354:	d4 06 e0 1c 	ld  [ %i3 + 0x1c ], %o2                        
40007358:	90 10 00 1b 	mov  %i3, %o0                                  
4000735c:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
40007360:	7f ff f9 bc 	call  40005a50 <rtems_fdisk_printf>            
40007364:	92 12 60 e0 	or  %o1, 0xe0, %o1	! 40035ce0 <Callbacks.6428+0xa98>
  rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);  
40007368:	d4 06 e0 20 	ld  [ %i3 + 0x20 ], %o2                        
4000736c:	90 10 00 1b 	mov  %i3, %o0                                  
40007370:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
40007374:	7f ff f9 b7 	call  40005a50 <rtems_fdisk_printf>            
40007378:	92 12 60 f0 	or  %o1, 0xf0, %o1	! 40035cf0 <Callbacks.6428+0xaa8>
  rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
4000737c:	d4 06 e0 24 	ld  [ %i3 + 0x24 ], %o2                        
40007380:	90 10 00 1b 	mov  %i3, %o0                                  
40007384:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
40007388:	7f ff f9 b2 	call  40005a50 <rtems_fdisk_printf>            
4000738c:	92 12 61 08 	or  %o1, 0x108, %o1	! 40035d08 <Callbacks.6428+0xac0>
  rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);        
40007390:	d4 06 e0 70 	ld  [ %i3 + 0x70 ], %o2                        
40007394:	90 10 00 1b 	mov  %i3, %o0                                  
40007398:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
4000739c:	7f ff f9 ad 	call  40005a50 <rtems_fdisk_printf>            
400073a0:	92 12 61 20 	or  %o1, 0x120, %o1	! 40035d20 <Callbacks.6428+0xad8>
 * 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;                          
400073a4:	c2 06 e0 34 	ld  [ %i3 + 0x34 ], %g1                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
400073a8:	80 a0 60 00 	cmp  %g1, 0                                    
400073ac:	22 80 00 07 	be,a   400073c8 <rtems_fdisk_ioctl+0x594>      <== NEVER TAKEN
400073b0:	d6 06 e0 3c 	ld  [ %i3 + 0x3c ], %o3                        <== NOT EXECUTED
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
400073b4:	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)                                                          
400073b8:	80 a0 60 00 	cmp  %g1, 0                                    
400073bc:	12 bf ff fe 	bne  400073b4 <rtems_fdisk_ioctl+0x580>        <== NEVER TAKEN
400073c0:	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)",               
400073c4:	d6 06 e0 3c 	ld  [ %i3 + 0x3c ], %o3                        
400073c8:	94 10 00 1d 	mov  %i5, %o2                                  
400073cc:	90 10 00 1b 	mov  %i3, %o0                                  
400073d0:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
400073d4:	7f ff f9 9f 	call  40005a50 <rtems_fdisk_printf>            
400073d8:	92 12 61 30 	or  %o1, 0x130, %o1	! 40035d30 <Callbacks.6428+0xae8>
 * 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;                          
400073dc:	c2 06 e0 40 	ld  [ %i3 + 0x40 ], %g1                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
400073e0:	80 a0 60 00 	cmp  %g1, 0                                    
400073e4:	02 80 00 06 	be  400073fc <rtems_fdisk_ioctl+0x5c8>         <== NEVER TAKEN
400073e8:	94 10 20 00 	clr  %o2                                       
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
400073ec:	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)                                                          
400073f0:	80 a0 60 00 	cmp  %g1, 0                                    
400073f4:	12 bf ff fe 	bne  400073ec <rtems_fdisk_ioctl+0x5b8>        
400073f8:	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)",                    
400073fc:	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;                                                     
40007400:	ba 02 80 1d 	add  %o2, %i5, %i5                             
  rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",                    
40007404:	90 10 00 1b 	mov  %i3, %o0                                  
40007408:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
4000740c:	7f ff f9 91 	call  40005a50 <rtems_fdisk_printf>            
40007410:	92 12 61 50 	or  %o1, 0x150, %o1	! 40035d50 <Callbacks.6428+0xb08>
 * 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;                          
40007414:	c2 06 e0 4c 	ld  [ %i3 + 0x4c ], %g1                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40007418:	80 a0 60 00 	cmp  %g1, 0                                    
4000741c:	02 80 00 06 	be  40007434 <rtems_fdisk_ioctl+0x600>         <== ALWAYS TAKEN
40007420:	94 10 20 00 	clr  %o2                                       
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
40007424:	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)                                                          
40007428:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000742c:	12 bf ff fe 	bne  40007424 <rtems_fdisk_ioctl+0x5f0>        <== NOT EXECUTED
40007430:	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)",                   
40007434:	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;                                                     
40007438:	ba 07 40 0a 	add  %i5, %o2, %i5                             
  rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",                   
4000743c:	90 10 00 1b 	mov  %i3, %o0                                  
40007440:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
40007444:	7f ff f9 83 	call  40005a50 <rtems_fdisk_printf>            
40007448:	92 12 61 68 	or  %o1, 0x168, %o1	! 40035d68 <Callbacks.6428+0xb20>
 * 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;                          
4000744c:	c4 06 e0 58 	ld  [ %i3 + 0x58 ], %g2                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40007450:	80 a0 a0 00 	cmp  %g2, 0                                    
40007454:	02 80 00 06 	be  4000746c <rtems_fdisk_ioctl+0x638>         <== ALWAYS TAKEN
40007458:	94 10 20 00 	clr  %o2                                       
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
4000745c:	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)                                                          
40007460:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40007464:	12 bf ff fe 	bne  4000745c <rtems_fdisk_ioctl+0x628>        <== NOT EXECUTED
40007468:	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)",                  
4000746c:	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;                                                     
40007470:	ba 07 40 0a 	add  %i5, %o2, %i5                             
  rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",                  
40007474:	90 10 00 1b 	mov  %i3, %o0                                  
40007478:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
4000747c:	7f ff f9 75 	call  40005a50 <rtems_fdisk_printf>            
40007480:	92 12 61 80 	or  %o1, 0x180, %o1	! 40035d80 <Callbacks.6428+0xb38>
                      count, rtems_fdisk_segment_queue_count (&fd->failed));
                                                                      
  count = 0;                                                          
  for (device = 0; device < fd->device_count; device++)               
40007484:	c4 06 e0 30 	ld  [ %i3 + 0x30 ], %g2                        
40007488:	80 a0 a0 00 	cmp  %g2, 0                                    
4000748c:	02 80 00 db 	be  400077f8 <rtems_fdisk_ioctl+0x9c4>         <== NEVER TAKEN
40007490:	87 28 a0 02 	sll  %g2, 2, %g3                               
40007494:	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;                                                          
40007498:	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)   
4000749c:	85 28 a0 04 	sll  %g2, 4, %g2                               
400074a0:	84 20 80 03 	sub  %g2, %g3, %g2                             
400074a4:	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;                       
400074a8:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
400074ac:	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++)               
400074b0:	80 a0 40 02 	cmp  %g1, %g2                                  
400074b4:	12 bf ff fd 	bne  400074a8 <rtems_fdisk_ioctl+0x674>        <== NEVER TAKEN
400074b8:	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,
400074bc:	19 10 00 d6 	sethi  %hi(0x40035800), %o4                    
400074c0:	80 a7 40 0b 	cmp  %i5, %o3                                  
400074c4:	02 80 02 71 	be  40007e88 <rtems_fdisk_ioctl+0x1054>        <== ALWAYS TAKEN
400074c8:	98 13 20 80 	or  %o4, 0x80, %o4                             
400074cc:	94 10 00 1d 	mov  %i5, %o2                                  
400074d0:	90 10 00 1b 	mov  %i3, %o0                                  
400074d4:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
400074d8:	7f ff f9 5e 	call  40005a50 <rtems_fdisk_printf>            
400074dc:	92 12 61 98 	or  %o1, 0x198, %o1	! 40035d98 <Callbacks.6428+0xb50>
                      total == count ? "ok" : "MISSING");             
                                                                      
  rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);      
400074e0:	d4 06 e0 30 	ld  [ %i3 + 0x30 ], %o2                        
400074e4:	90 10 00 1b 	mov  %i3, %o0                                  
400074e8:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
400074ec:	7f ff f9 59 	call  40005a50 <rtems_fdisk_printf>            
400074f0:	92 12 61 b8 	or  %o1, 0x1b8, %o1	! 40035db8 <Callbacks.6428+0xb70>
                                                                      
  for (device = 0; device < fd->device_count; device++)               
400074f4:	c2 06 e0 30 	ld  [ %i3 + 0x30 ], %g1                        
400074f8:	80 a0 60 00 	cmp  %g1, 0                                    
400074fc:	22 80 00 8e 	be,a   40007734 <rtems_fdisk_ioctl+0x900>      <== NEVER TAKEN
40007500:	fa 06 e0 40 	ld  [ %i3 + 0x40 ], %i5                        <== NOT EXECUTED
40007504:	b0 10 20 00 	clr  %i0                                       
40007508:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
  {                                                                   
    uint32_t block;                                                   
    uint32_t seg;                                                     
                                                                      
    rtems_fdisk_printf (fd, " Device\t\t%ld", device);                
4000750c:	d4 07 bf ec 	ld  [ %fp + -20 ], %o2                         
40007510:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
40007514:	90 10 00 1b 	mov  %i3, %o0                                  
40007518:	7f ff f9 4e 	call  40005a50 <rtems_fdisk_printf>            
4000751c:	92 12 61 c8 	or  %o1, 0x1c8, %o1                            
    rtems_fdisk_printf (fd, "  Segment count\t%ld",                   
40007520:	c2 06 e0 2c 	ld  [ %i3 + 0x2c ], %g1                        
40007524:	90 10 00 1b 	mov  %i3, %o0                                  
40007528:	82 00 40 18 	add  %g1, %i0, %g1                             
4000752c:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
40007530:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
40007534:	7f ff f9 47 	call  40005a50 <rtems_fdisk_printf>            
40007538:	92 12 61 d8 	or  %o1, 0x1d8, %o1	! 40035dd8 <Callbacks.6428+0xb90>
                        fd->devices[device].segment_count);           
                                                                      
    for (seg = 0; seg < fd->devices[device].segment_count; seg++)     
4000753c:	c2 06 e0 2c 	ld  [ %i3 + 0x2c ], %g1                        
40007540:	82 00 40 18 	add  %g1, %i0, %g1                             
40007544:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40007548:	80 a0 a0 00 	cmp  %g2, 0                                    
4000754c:	02 80 00 73 	be  40007718 <rtems_fdisk_ioctl+0x8e4>         <== NEVER TAKEN
40007550:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
40007554:	b2 10 20 00 	clr  %i1                                       
40007558:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
      rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
4000755c:	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);                      
40007560:	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];
40007564:	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);                      
40007568:	94 07 bf f8 	add  %fp, -8, %o2                              
4000756c:	7f ff f8 b9 	call  40005850 <rtems_fdisk_queue_status>      
40007570:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
      for (page = 0; page < sc->pages; page++)                        
40007574:	d8 07 20 14 	ld  [ %i4 + 0x14 ], %o4                        
40007578:	80 a3 20 00 	cmp  %o4, 0                                    
4000757c:	22 80 00 94 	be,a   400077cc <rtems_fdisk_ioctl+0x998>      <== NEVER TAKEN
40007580:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        <== NOT EXECUTED
40007584:	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;                     
40007588:	a8 10 20 00 	clr  %l4                                       
4000758c:	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;                            
40007590:	ae 10 20 00 	clr  %l7                                       
      uint32_t                 used = 0;                              
40007594:	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;                            
40007598:	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++)                        
4000759c:	a4 10 20 00 	clr  %l2                                       
      {                                                               
        if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
400075a0:	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)   
400075a4:	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;                  
400075a8:	fa 01 00 02 	ld  [ %g4 + %g2 ], %i5                         
400075ac:	80 a7 7f ff 	cmp  %i5, -1                                   
400075b0:	02 80 00 7d 	be  400077a4 <rtems_fdisk_ioctl+0x970>         
400075b4:	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;                     
400075b8:	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],
400075bc:	80 88 a0 01 	btst  1, %g2                                   
400075c0:	12 80 00 07 	bne  400075dc <rtems_fdisk_ioctl+0x7a8>        <== NEVER TAKEN
400075c4:	80 a0 e0 00 	cmp  %g3, 0                                    
                                                  RTEMS_FDISK_PAGE_ACTIVE))
        {                                                             
          if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
400075c8:	80 88 a0 02 	btst  2, %g2                                   
400075cc:	32 80 00 7c 	bne,a   400077bc <rtems_fdisk_ioctl+0x988>     
400075d0:	ae 05 e0 01 	inc  %l7                                       
                                               RTEMS_FDISK_PAGE_USED))
            used++;                                                   
400075d4:	ac 05 a0 01 	inc  %l6                                       
            active++;                                                 
            is_active = true;                                         
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
400075d8:	80 a0 e0 00 	cmp  %g3, 0                                    
400075dc:	22 80 00 23 	be,a   40007668 <rtems_fdisk_ioctl+0x834>      <== NEVER TAKEN
400075e0:	a4 04 a0 01 	inc  %l2                                       <== NOT EXECUTED
400075e4:	ba 10 20 00 	clr  %i5                                       
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
              (fd->blocks[block].page == page) && !is_active)         
400075e8:	10 80 00 06 	b  40007600 <rtems_fdisk_ioctl+0x7cc>          
400075ec:	a6 0d 20 ff 	and  %l4, 0xff, %l3                            
            active++;                                                 
            is_active = true;                                         
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
400075f0:	ba 07 60 01 	inc  %i5                                       
400075f4:	80 a7 40 03 	cmp  %i5, %g3                                  
400075f8:	1a 80 00 1a 	bcc  40007660 <rtems_fdisk_ioctl+0x82c>        
400075fc:	82 10 00 03 	mov  %g3, %g1                                  
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
40007600:	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)   
40007604:	83 2f 60 03 	sll  %i5, 3, %g1                               
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
        {                                                             
          if ((fd->blocks[block].segment == sc) &&                    
40007608:	c8 00 80 01 	ld  [ %g2 + %g1 ], %g4                         
4000760c:	80 a7 00 04 	cmp  %i4, %g4                                  
40007610:	12 bf ff f8 	bne  400075f0 <rtems_fdisk_ioctl+0x7bc>        
40007614:	82 00 80 01 	add  %g2, %g1, %g1                             
40007618:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000761c:	80 a4 80 01 	cmp  %l2, %g1                                  
40007620:	32 bf ff f5 	bne,a   400075f4 <rtems_fdisk_ioctl+0x7c0>     
40007624:	ba 07 60 01 	inc  %i5                                       
              (fd->blocks[block].page == page) && !is_active)         
40007628:	80 a4 e0 00 	cmp  %l3, 0                                    
4000762c:	32 bf ff f2 	bne,a   400075f4 <rtems_fdisk_ioctl+0x7c0>     <== ALWAYS TAKEN
40007630:	ba 07 60 01 	inc  %i5                                       
            rtems_fdisk_printf (fd,                                   
40007634:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
40007638:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4000763c:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    <== NOT EXECUTED
40007640:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
40007644:	7f ff f9 03 	call  40005a50 <rtems_fdisk_printf>            <== NOT EXECUTED
40007648:	92 12 61 f0 	or  %o1, 0x1f0, %o1                            <== NOT EXECUTED
4000764c:	c6 06 e0 1c 	ld  [ %i3 + 0x1c ], %g3                        <== NOT EXECUTED
            active++;                                                 
            is_active = true;                                         
          }                                                           
        }                                                             
                                                                      
        for (block = 0; block < fd->block_count; block++)             
40007650:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
40007654:	80 a7 40 03 	cmp  %i5, %g3                                  <== NOT EXECUTED
40007658:	0a bf ff ea 	bcs  40007600 <rtems_fdisk_ioctl+0x7cc>        <== NOT EXECUTED
4000765c:	82 10 00 03 	mov  %g3, %g1                                  <== NOT EXECUTED
40007660:	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++)                        
40007664:	a4 04 a0 01 	inc  %l2                                       
40007668:	80 a4 80 0c 	cmp  %l2, %o4                                  
4000766c:	2a bf ff ce 	bcs,a   400075a4 <rtems_fdisk_ioctl+0x770>     
40007670:	c8 07 20 10 	ld  [ %i4 + 0x10 ], %g4                        
                                page, block);                         
        }                                                             
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
40007674:	80 a0 60 00 	cmp  %g1, 0                                    
40007678:	02 80 00 53 	be  400077c4 <rtems_fdisk_ioctl+0x990>         <== NEVER TAKEN
4000767c:	83 28 60 03 	sll  %g1, 3, %g1                               
40007680:	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)   
40007684:	84 10 20 00 	clr  %g2                                       
40007688:	86 10 20 00 	clr  %g3                                       
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
      {                                                               
        if (fd->blocks[block].segment == sc)                          
4000768c:	c8 07 40 02 	ld  [ %i5 + %g2 ], %g4                         
40007690:	84 00 a0 08 	add  %g2, 8, %g2                               
          count++;                                                    
40007694:	88 1f 00 04 	xor  %i4, %g4, %g4                             
40007698:	80 a0 00 04 	cmp  %g0, %g4                                  
4000769c:	86 60 ff ff 	subx  %g3, -1, %g3                             
                                page, block);                         
        }                                                             
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
400076a0:	80 a0 80 01 	cmp  %g2, %g1                                  
400076a4:	32 bf ff fb 	bne,a   40007690 <rtems_fdisk_ioctl+0x85c>     
400076a8:	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),
400076ac:	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 +             
400076b0:	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" \        
400076b4:	c4 23 a0 60 	st  %g2, [ %sp + 0x60 ]                        
400076b8:	ee 23 a0 5c 	st  %l7, [ %sp + 0x5c ]                        
400076bc:	ec 23 a0 64 	st  %l6, [ %sp + 0x64 ]                        
400076c0:	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)   
400076c4:	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" \        
400076c8:	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)   
400076cc:	84 00 80 04 	add  %g2, %g4, %g2                             
400076d0:	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" \        
400076d4:	84 23 00 02 	sub  %o4, %g2, %g2                             
400076d8:	9a 10 00 01 	mov  %g1, %o5                                  
400076dc:	c4 23 a0 6c 	st  %g2, [ %sp + 0x6c ]                        
400076e0:	c6 23 a0 70 	st  %g3, [ %sp + 0x70 ]                        
400076e4:	90 10 00 1b 	mov  %i3, %o0                                  
400076e8:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
400076ec:	96 07 bf f8 	add  %fp, -8, %o3                              
400076f0:	7f ff f8 d8 	call  40005a50 <rtems_fdisk_printf>            
400076f4:	92 12 62 20 	or  %o1, 0x220, %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++)     
400076f8:	c2 06 e0 2c 	ld  [ %i3 + 0x2c ], %g1                        
400076fc:	b4 06 a0 01 	inc  %i2                                       
40007700:	82 00 40 18 	add  %g1, %i0, %g1                             
40007704:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40007708:	80 a6 80 02 	cmp  %i2, %g2                                  
4000770c:	0a bf ff 94 	bcs  4000755c <rtems_fdisk_ioctl+0x728>        
40007710:	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++)               
40007714:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
40007718:	c2 06 e0 30 	ld  [ %i3 + 0x30 ], %g1                        
4000771c:	84 00 a0 01 	inc  %g2                                       
40007720:	c4 27 bf ec 	st  %g2, [ %fp + -20 ]                         
40007724:	80 a0 80 01 	cmp  %g2, %g1                                  
40007728:	0a bf ff 79 	bcs  4000750c <rtems_fdisk_ioctl+0x6d8>        <== NEVER TAKEN
4000772c:	b0 06 20 0c 	add  %i0, 0xc, %i0                             
                          count);                                     
    }                                                                 
  }                                                                   
                                                                      
  {                                                                   
    rtems_fdisk_segment_ctl* sc = fd->used.head;                      
40007730:	fa 06 e0 40 	ld  [ %i3 + 0x40 ], %i5                        
    int count = 0;                                                    
    rtems_fdisk_printf (fd, "Used List:");                            
40007734:	90 10 00 1b 	mov  %i3, %o0                                  
40007738:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    
4000773c:	7f ff f8 c5 	call  40005a50 <rtems_fdisk_printf>            
40007740:	92 12 62 60 	or  %o1, 0x260, %o1	! 40035e60 <Callbacks.6428+0xc18>
    while (sc)                                                        
40007744:	80 a7 60 00 	cmp  %i5, 0                                    
40007748:	02 80 00 11 	be  4000778c <rtems_fdisk_ioctl+0x958>         <== NEVER TAKEN
4000774c:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
    {                                                                 
      rtems_fdisk_printf (fd, "  %3d %02d:%03d u:%3ld",               
40007750:	35 10 00 d7 	sethi  %hi(0x40035c00), %i2                    
                                                                      
  {                                                                   
    rtems_fdisk_segment_ctl* sc = fd->used.head;                      
    int count = 0;                                                    
    rtems_fdisk_printf (fd, "Used List:");                            
    while (sc)                                                        
40007754:	b8 10 20 00 	clr  %i4                                       
    {                                                                 
      rtems_fdisk_printf (fd, "  %3d %02d:%03d u:%3ld",               
40007758:	b4 16 a2 70 	or  %i2, 0x270, %i2                            
4000775c:	d6 07 60 08 	ld  [ %i5 + 8 ], %o3                           
40007760:	d8 07 60 0c 	ld  [ %i5 + 0xc ], %o4                         
40007764:	da 07 60 20 	ld  [ %i5 + 0x20 ], %o5                        
40007768:	94 10 00 1c 	mov  %i4, %o2                                  
4000776c:	90 10 00 1b 	mov  %i3, %o0                                  
40007770:	7f ff f8 b8 	call  40005a50 <rtems_fdisk_printf>            
40007774:	92 10 00 1a 	mov  %i2, %o1                                  
                          count, sc->device, sc->segment, sc->pages_used);
      sc = sc->next;                                                  
40007778:	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)                                                        
4000777c:	80 a7 60 00 	cmp  %i5, 0                                    
40007780:	12 bf ff f7 	bne  4000775c <rtems_fdisk_ioctl+0x928>        
40007784:	b8 07 20 01 	inc  %i4                                       
                          count, sc->device, sc->segment, sc->pages_used);
      sc = sc->next;                                                  
      count++;                                                        
    }                                                                 
  }                                                                   
  fd->info_level = current_info_level;                                
40007788:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
4000778c:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       
40007790:	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]);  
40007794:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
40007798:	84 00 80 15 	add  %g2, %l5, %g2                             
        break;                                                        
4000779c:	10 bf fe 8b 	b  400071c8 <rtems_fdisk_ioctl+0x394>          
400077a0:	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;                  
400077a4:	c8 00 a0 04 	ld  [ %g2 + 4 ], %g4                           
400077a8:	80 a1 3f ff 	cmp  %g4, -1                                   
400077ac:	32 bf ff 84 	bne,a   400075bc <rtems_fdisk_ioctl+0x788>     <== NEVER TAKEN
400077b0:	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++;                                                   
400077b4:	10 bf ff 89 	b  400075d8 <rtems_fdisk_ioctl+0x7a4>          
400077b8:	a2 04 60 01 	inc  %l1                                       
                                               RTEMS_FDISK_PAGE_USED))
            used++;                                                   
          else                                                        
          {                                                           
            active++;                                                 
            is_active = true;                                         
400077bc:	10 bf ff 87 	b  400075d8 <rtems_fdisk_ioctl+0x7a4>          
400077c0:	a8 10 20 01 	mov  1, %l4                                    
                                page, block);                         
        }                                                             
      }                                                               
                                                                      
      count = 0;                                                      
      for (block = 0; block < fd->block_count; block++)               
400077c4:	10 bf ff ba 	b  400076ac <rtems_fdisk_ioctl+0x878>          <== NOT EXECUTED
400077c8:	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;                            
400077cc:	ae 10 20 00 	clr  %l7                                       <== NOT EXECUTED
      uint32_t                 used = 0;                              
400077d0:	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;                            
400077d4:	10 bf ff a8 	b  40007674 <rtems_fdisk_ioctl+0x840>          <== NOT EXECUTED
400077d8:	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;                                             
400077dc:	40 00 70 d7 	call  40023b38 <__errno>                       <== NOT EXECUTED
400077e0:	01 00 00 00 	nop                                            <== NOT EXECUTED
400077e4:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       <== NOT EXECUTED
400077e8:	82 10 20 13 	mov  0x13, %g1                                 <== NOT EXECUTED
400077ec:	84 00 80 15 	add  %g2, %l5, %g2                             <== NOT EXECUTED
400077f0:	10 bf fe 76 	b  400071c8 <rtems_fdisk_ioctl+0x394>          <== NOT EXECUTED
400077f4:	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;                                                          
400077f8:	10 bf ff 31 	b  400074bc <rtems_fdisk_ioctl+0x688>          <== NOT EXECUTED
400077fc:	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);
40007800:	40 00 70 ce 	call  40023b38 <__errno>                       
40007804:	a8 06 a0 28 	add  %i2, 0x28, %l4                            
40007808:	fa 04 23 70 	ld  [ %l0 + 0x370 ], %i5                       
4000780c:	f8 06 a0 10 	ld  [ %i2 + 0x10 ], %i4                        
40007810:	d0 27 bf e0 	st  %o0, [ %fp + -32 ]                         
40007814:	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)   
40007818:	ac 10 20 01 	mov  1, %l6                                    
4000781c:	f4 27 bf ec 	st  %i2, [ %fp + -20 ]                         
40007820:	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++)       
40007824:	82 05 bf ff 	add  %l6, -1, %g1                              
40007828:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000782c:	3a 80 02 7d 	bcc,a   40008220 <rtems_fdisk_ioctl+0x13ec>    
40007830:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         
  {                                                                   
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
40007834:	d0 05 3f f4 	ld  [ %l4 + -12 ], %o0                         
40007838:	7f ff eb 9a 	call  400026a0 <.udiv>                         
4000783c:	d2 07 60 14 	ld  [ %i5 + 0x14 ], %o1                        
40007840:	d0 27 bf e4 	st  %o0, [ %fp + -28 ]                         
    data = sg->buffer;                                                
    for (b = 0; b < fb; b++, data += fd->block_size)                  
40007844:	80 a2 20 00 	cmp  %o0, 0                                    
40007848:	02 80 01 0e 	be  40007c80 <rtems_fdisk_ioctl+0xe4c>         <== NEVER TAKEN
4000784c:	f4 05 3f f8 	ld  [ %l4 + -8 ], %i2                          
40007850:	b2 10 20 00 	clr  %i1                                       
40007854:	ec 27 bf dc 	st  %l6, [ %fp + -36 ]                         
    {                                                                 
      ret = rtems_fdisk_write_block (fd, sg->block + b, data);        
40007858:	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);                     
4000785c:	05 10 00 d6 	sethi  %hi(0x40035800), %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);        
40007860:	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);                     
40007864:	92 10 a2 08 	or  %g2, 0x208, %o1                            
40007868:	90 10 00 1d 	mov  %i5, %o0                                  
4000786c:	7f ff f8 57 	call  400059c8 <rtems_fdisk_info>              
40007870:	94 10 00 17 	mov  %l7, %o2                                  
                                                                      
  /*                                                                  
   * Broken out to allow info messages when testing.                  
   */                                                                 
                                                                      
  if (block >= (fd->block_count - fd->unavail_blocks))                
40007874:	c4 07 60 1c 	ld  [ %i5 + 0x1c ], %g2                        
40007878:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
4000787c:	82 20 80 01 	sub  %g2, %g1, %g1                             
40007880:	80 a5 c0 01 	cmp  %l7, %g1                                  
40007884:	1a 80 01 02 	bcc  40007c8c <rtems_fdisk_ioctl+0xe58>        <== NEVER TAKEN
40007888:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    
  {                                                                   
    rtems_fdisk_error ("write-block: block out of range: %d", block); 
    return EIO;                                                       
  }                                                                   
                                                                      
  bc = &fd->blocks[block];                                            
4000788c:	e6 07 60 18 	ld  [ %i5 + 0x18 ], %l3                        
40007890:	a5 2d e0 03 	sll  %l7, 3, %l2                               
                                                                      
  /*                                                                  
   * Does the page exist in flash ?                                   
   */                                                                 
  if (bc->segment)                                                    
40007894:	f8 04 c0 12 	ld  [ %l3 + %l2 ], %i4                         
40007898:	80 a7 20 00 	cmp  %i4, 0                                    
4000789c:	02 80 00 6d 	be  40007a50 <rtems_fdisk_ioctl+0xc1c>         
400078a0:	a2 04 c0 12 	add  %l3, %l2, %l1                             
  {                                                                   
    sc = bc->segment;                                                 
    pd = &sc->page_descriptors[bc->page];                             
400078a4:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
400078a8:	d4 07 20 08 	ld  [ %i4 + 8 ], %o2                           
400078ac:	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];                             
400078b0:	f0 07 20 10 	ld  [ %i4 + 0x10 ], %i0                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
400078b4:	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];                             
400078b8:	83 28 60 03 	sll  %g1, 3, %g1                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
400078bc:	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];                             
400078c0:	b0 06 00 01 	add  %i0, %g1, %i0                             
                                                                      
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",         
400078c4:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    
400078c8:	7f ff f8 40 	call  400059c8 <rtems_fdisk_info>              
400078cc:	92 12 62 40 	or  %o1, 0x240, %o1	! 40035a40 <Callbacks.6428+0x7f8>
#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,     
400078d0:	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);
400078d4:	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,     
400078d8:	d0 07 20 18 	ld  [ %i4 + 0x18 ], %o0                        
400078dc:	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,                 
400078e0:	92 10 00 16 	mov  %l6, %o1                                  
400078e4:	7f ff eb 35 	call  400025b8 <.umul>                         
400078e8:	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;            
400078ec:	c8 07 60 2c 	ld  [ %i5 + 0x2c ], %g4                        
400078f0:	b7 2d 60 04 	sll  %l5, 4, %i3                               
400078f4:	87 2d 60 02 	sll  %l5, 2, %g3                               
400078f8:	86 26 c0 03 	sub  %i3, %g3, %g3                             
400078fc:	b6 01 00 03 	add  %g4, %g3, %i3                             
40007900:	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;                    
40007904:	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,     
40007908:	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;                    
4000790c:	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;            
40007910:	93 2e e0 06 	sll  %i3, 6, %o1                               
40007914:	89 2e e0 04 	sll  %i3, 4, %g4                               
40007918:	88 22 40 04 	sub  %o1, %g4, %g4                             
4000791c:	88 03 c0 04 	add  %o7, %g4, %g4                             
40007920:	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,                 
40007924:	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",     
40007928:	98 10 00 08 	mov  %o0, %o4                                  
4000792c:	c4 3f bf d0 	std  %g2, [ %fp + -48 ]                        
40007930:	94 10 00 15 	mov  %l5, %o2                                  
40007934:	96 10 00 1b 	mov  %i3, %o3                                  
40007938:	9a 10 00 16 	mov  %l6, %o5                                  
4000793c:	c8 27 bf cc 	st  %g4, [ %fp + -52 ]                         
40007940:	90 10 00 1d 	mov  %i5, %o0                                  
40007944:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    
40007948:	7f ff f8 42 	call  40005a50 <rtems_fdisk_printf>            
4000794c:	92 12 62 68 	or  %o1, 0x268, %o1	! 40035a68 <Callbacks.6428+0x820>
                      device, segment, offset, size);                 
#endif                                                                
  return ops->verify (sd, device, segment, offset, buffer, size);     
40007950:	c6 07 bf d4 	ld  [ %fp + -44 ], %g3                         
40007954:	c8 07 bf cc 	ld  [ %fp + -52 ], %g4                         
40007958:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         
4000795c:	c6 00 e0 0c 	ld  [ %g3 + 0xc ], %g3                         
40007960:	90 10 00 04 	mov  %g4, %o0                                  
40007964:	92 10 00 15 	mov  %l5, %o1                                  
40007968:	94 10 00 1b 	mov  %i3, %o2                                  
4000796c:	96 10 00 02 	mov  %g2, %o3                                  
40007970:	98 10 00 1a 	mov  %i2, %o4                                  
40007974:	9f c0 c0 00 	call  %g3                                      
40007978:	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,     
4000797c:	80 a2 20 00 	cmp  %o0, 0                                    
40007980:	22 80 00 f9 	be,a   40007d64 <rtems_fdisk_ioctl+0xf30>      
40007984:	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;                                                
40007988:	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);
4000798c:	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))             
40007990:	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;                                                
40007994:	86 08 ff fd 	and  %g3, -3, %g3                              
40007998:	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)) +        
4000799c:	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))             
400079a0:	80 88 a0 08 	btst  8, %g2                                   
400079a4:	02 80 00 d6 	be  40007cfc <rtems_fdisk_ioctl+0xec8>         <== NEVER TAKEN
400079a8:	aa 05 60 02 	add  %l5, 2, %l5                               
  {                                                                   
    uint16_t flash_flags;                                             
    int      ret;                                                     
    ret = rtems_fdisk_seg_read (fd, sc, offset,                       
400079ac:	c2 27 bf d8 	st  %g1, [ %fp + -40 ]                         
400079b0:	90 10 00 1d 	mov  %i5, %o0                                  
400079b4:	92 10 00 1c 	mov  %i4, %o1                                  
400079b8:	94 10 00 15 	mov  %l5, %o2                                  
400079bc:	96 07 bf f6 	add  %fp, -10, %o3                             
400079c0:	7f ff f8 46 	call  40005ad8 <rtems_fdisk_seg_read>          
400079c4:	98 10 20 02 	mov  2, %o4                                    
                                &flash_flags, sizeof (flash_flags));  
    if (ret)                                                          
400079c8:	b6 92 20 00 	orcc  %o0, 0, %i3                              
400079cc:	12 80 00 d5 	bne  40007d20 <rtems_fdisk_ioctl+0xeec>        <== NEVER TAKEN
400079d0:	c2 07 bf d8 	ld  [ %fp + -40 ], %g1                         
      return ret;                                                     
    if ((flash_flags & page_desc->flags) != page_desc->flags)         
400079d4:	c8 16 20 02 	lduh  [ %i0 + 2 ], %g4                         
400079d8:	c4 17 bf f6 	lduh  [ %fp + -10 ], %g2                       
400079dc:	87 29 20 10 	sll  %g4, 0x10, %g3                            
400079e0:	88 08 80 04 	and  %g2, %g4, %g4                             
400079e4:	89 29 20 10 	sll  %g4, 0x10, %g4                            
400079e8:	80 a1 00 03 	cmp  %g4, %g3                                  
400079ec:	02 80 00 c4 	be  40007cfc <rtems_fdisk_ioctl+0xec8>         <== ALWAYS TAKEN
400079f0:	9b 30 e0 10 	srl  %g3, 0x10, %o5                            
    {                                                                 
      rtems_fdisk_error ("  seg-write-page-flags: %02d-%03d-%03d: "   
400079f4:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           <== NOT EXECUTED
400079f8:	d4 07 20 0c 	ld  [ %i4 + 0xc ], %o2                         <== NOT EXECUTED
400079fc:	99 28 a0 10 	sll  %g2, 0x10, %o4                            <== NOT EXECUTED
40007a00:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40007a04:	96 10 00 01 	mov  %g1, %o3                                  <== NOT EXECUTED
40007a08:	90 12 22 c0 	or  %o0, 0x2c0, %o0                            <== NOT EXECUTED
40007a0c:	7f ff f8 eb 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40007a10:	99 33 20 10 	srl  %o4, 0x10, %o4                            <== NOT EXECUTED
                        strerror (ret), ret);                         
#endif                                                                
    }                                                                 
    else                                                              
    {                                                                 
      sc->pages_active--;                                             
40007a14:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        <== NOT EXECUTED
      sc->pages_used++;                                               
40007a18:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        
                        strerror (ret), ret);                         
#endif                                                                
    }                                                                 
    else                                                              
    {                                                                 
      sc->pages_active--;                                             
40007a1c:	84 00 bf ff 	add  %g2, -1, %g2                              
      sc->pages_used++;                                               
40007a20:	82 00 60 01 	inc  %g1                                       
                        strerror (ret), ret);                         
#endif                                                                
    }                                                                 
    else                                                              
    {                                                                 
      sc->pages_active--;                                             
40007a24:	c4 27 20 1c 	st  %g2, [ %i4 + 0x1c ]                        
      sc->pages_used++;                                               
40007a28:	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);                               
40007a2c:	90 10 00 1d 	mov  %i5, %o0                                  
40007a30:	7f ff f9 8a 	call  40006058 <rtems_fdisk_queue_segment>     
40007a34:	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)            
40007a38:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
40007a3c:	80 88 60 02 	btst  2, %g1                                   
40007a40:	32 80 00 05 	bne,a   40007a54 <rtems_fdisk_ioctl+0xc20>     <== NEVER TAKEN
40007a44:	f8 07 60 34 	ld  [ %i5 + 0x34 ], %i4                        <== NOT EXECUTED
      rtems_fdisk_compact (fd);                                       
40007a48:	7f ff fb 50 	call  40006788 <rtems_fdisk_compact>           
40007a4c:	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;                          
40007a50:	f8 07 60 34 	ld  [ %i5 + 0x34 ], %i4                        
  uint32_t                 count = 0;                                 
                                                                      
  while (sc)                                                          
40007a54:	80 a7 20 00 	cmp  %i4, 0                                    
40007a58:	02 80 00 e7 	be  40007df4 <rtems_fdisk_ioctl+0xfc0>         <== NEVER TAKEN
40007a5c:	82 10 00 1c 	mov  %i4, %g1                                  
40007a60:	84 10 20 00 	clr  %g2                                       
  {                                                                   
    count++;                                                          
    sc = sc->next;                                                    
40007a64:	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)                                                          
40007a68:	80 a0 60 00 	cmp  %g1, 0                                    
40007a6c:	12 bf ff fe 	bne  40007a64 <rtems_fdisk_ioctl+0xc30>        
40007a70:	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) <=             
40007a74:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
40007a78:	80 a0 40 02 	cmp  %g1, %g2                                  
40007a7c:	1a 80 00 de 	bcc  40007df4 <rtems_fdisk_ioctl+0xfc0>        
40007a80:	01 00 00 00 	nop                                            
{                                                                     
  if (queue->head)                                                    
  {                                                                   
    rtems_fdisk_segment_ctl* sc = queue->head;                        
                                                                      
    queue->head = sc->next;                                           
40007a84:	c2 07 00 00 	ld  [ %i4 ], %g1                               
    if (!queue->head)                                                 
40007a88:	80 a0 60 00 	cmp  %g1, 0                                    
40007a8c:	02 80 00 d8 	be  40007dec <rtems_fdisk_ioctl+0xfb8>         
40007a90:	c2 27 60 34 	st  %g1, [ %i5 + 0x34 ]                        
      queue->tail = 0;                                                
                                                                      
    queue->count--;                                                   
40007a94:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
40007a98:	82 00 7f ff 	add  %g1, -1, %g1                              
40007a9c:	c2 27 60 3c 	st  %g1, [ %i5 + 0x3c ]                        
      return ENOSPC;                                                  
    }                                                                 
  }                                                                   
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  if (fd->info_level >= 3)                                            
40007aa0:	c2 07 60 6c 	ld  [ %i5 + 0x6c ], %g1                        
40007aa4:	80 a0 60 02 	cmp  %g1, 2                                    
40007aa8:	18 80 00 b8 	bgu  40007d88 <rtems_fdisk_ioctl+0xf54>        <== NEVER TAKEN
40007aac:	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++)                      
40007ab0:	c6 07 20 14 	ld  [ %i4 + 0x14 ], %g3                        
40007ab4:	80 a0 e0 00 	cmp  %g3, 0                                    
40007ab8:	02 80 00 83 	be  40007cc4 <rtems_fdisk_ioctl+0xe90>         <== NEVER TAKEN
40007abc:	f6 07 20 10 	ld  [ %i4 + 0x10 ], %i3                        
40007ac0:	10 80 00 05 	b  40007ad4 <rtems_fdisk_ioctl+0xca0>          
40007ac4:	b0 10 20 00 	clr  %i0                                       
40007ac8:	80 a6 00 03 	cmp  %i0, %g3                                  
40007acc:	02 80 00 7e 	be  40007cc4 <rtems_fdisk_ioctl+0xe90>         <== NEVER TAKEN
40007ad0:	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;                  
40007ad4:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
40007ad8:	80 a0 7f ff 	cmp  %g1, -1                                   
40007adc:	32 bf ff fb 	bne,a   40007ac8 <rtems_fdisk_ioctl+0xc94>     
40007ae0:	b0 06 20 01 	inc  %i0                                       
40007ae4:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
40007ae8:	80 a0 7f ff 	cmp  %g1, -1                                   
40007aec:	32 bf ff f7 	bne,a   40007ac8 <rtems_fdisk_ioctl+0xc94>     <== NEVER TAKEN
40007af0:	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); 
40007af4:	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++)                           
40007af8:	80 a3 e0 00 	cmp  %o7, 0                                    
40007afc:	02 80 00 e0 	be  40007e7c <rtems_fdisk_ioctl+0x1048>        <== NEVER TAKEN
40007b00:	15 10 00 d7 	sethi  %hi(0x40035c00), %o2                    
40007b04:	03 10 01 2a 	sethi  %hi(0x4004a800), %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)   
40007b08:	9e 06 80 0f 	add  %i2, %o7, %o7                             
40007b0c:	da 00 63 78 	ld  [ %g1 + 0x378 ], %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;                                               
40007b10:	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)   
40007b14:	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);                        
40007b18:	c8 08 40 00 	ldub  [ %g1 ], %g4                             
40007b1c:	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++)                           
40007b20:	82 00 60 01 	inc  %g1                                       
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
40007b24:	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++)                           
40007b28:	80 a0 40 0f 	cmp  %g1, %o7                                  
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
40007b2c:	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++)                           
40007b30:	12 bf ff fa 	bne  40007b18 <rtems_fdisk_ioctl+0xce4>        
40007b34:	c4 13 40 02 	lduh  [ %o5 + %g2 ], %g2                       
40007b38:	83 28 a0 10 	sll  %g2, 0x10, %g1                            
40007b3c:	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;                                                
40007b40:	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); 
40007b44:	c4 36 c0 00 	sth  %g2, [ %i3 ]                              
      pd->block = block;                                              
40007b48:	ee 26 e0 04 	st  %l7, [ %i3 + 4 ]                           
                                                                      
      bc->segment = sc;                                               
40007b4c:	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: " \    
40007b50:	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;                                             
40007b54:	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;                                                
40007b58:	88 09 3f fe 	and  %g4, -2, %g4                              
40007b5c:	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: " \    
40007b60:	d6 07 20 08 	ld  [ %i4 + 8 ], %o3                           
40007b64:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         
40007b68:	e4 07 20 1c 	ld  [ %i4 + 0x1c ], %l2                        
40007b6c:	d0 07 20 20 	ld  [ %i4 + 0x20 ], %o0                        
40007b70:	80 a0 a0 00 	cmp  %g2, 0                                    
40007b74:	02 80 00 bf 	be  40007e70 <rtems_fdisk_ioctl+0x103c>        <== ALWAYS TAKEN
40007b78:	de 07 20 24 	ld  [ %i4 + 0x24 ], %o7                        
40007b7c:	05 10 00 d5 	sethi  %hi(0x40035400), %g2                    <== NOT EXECUTED
40007b80:	84 10 a0 68 	or  %g2, 0x68, %g2	! 40035468 <Callbacks.6428+0x220><== NOT EXECUTED
40007b84:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40007b88:	89 31 20 10 	srl  %g4, 0x10, %g4                            
40007b8c:	94 10 00 17 	mov  %l7, %o2                                  
40007b90:	9a 10 00 18 	mov  %i0, %o5                                  
40007b94:	c6 23 a0 5c 	st  %g3, [ %sp + 0x5c ]                        
40007b98:	e4 23 a0 60 	st  %l2, [ %sp + 0x60 ]                        
40007b9c:	d0 23 a0 64 	st  %o0, [ %sp + 0x64 ]                        
40007ba0:	de 23 a0 68 	st  %o7, [ %sp + 0x68 ]                        
40007ba4:	c4 23 a0 6c 	st  %g2, [ %sp + 0x6c ]                        
40007ba8:	c8 23 a0 70 	st  %g4, [ %sp + 0x70 ]                        
40007bac:	c2 23 a0 74 	st  %g1, [ %sp + 0x74 ]                        
40007bb0:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    
40007bb4:	ee 23 a0 78 	st  %l7, [ %sp + 0x78 ]                        
40007bb8:	92 12 63 78 	or  %o1, 0x378, %o1                            
40007bbc:	7f ff f7 83 	call  400059c8 <rtems_fdisk_info>              
40007bc0:	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);
40007bc4:	d4 07 20 18 	ld  [ %i4 + 0x18 ], %o2                        
40007bc8:	90 10 00 1d 	mov  %i5, %o0                                  
40007bcc:	92 10 00 1c 	mov  %i4, %o1                                  
40007bd0:	94 06 00 0a 	add  %i0, %o2, %o2                             
40007bd4:	7f ff f8 3b 	call  40005cc0 <rtems_fdisk_seg_write_page>    
40007bd8:	96 10 00 1a 	mov  %i2, %o3                                  
      if (ret)                                                        
40007bdc:	a4 92 20 00 	orcc  %o0, 0, %l2                              
40007be0:	22 80 00 78 	be,a   40007dc0 <rtems_fdisk_ioctl+0xf8c>      <== ALWAYS TAKEN
40007be4:	90 10 00 1d 	mov  %i5, %o0                                  
      {                                                               
#if RTEMS_FDISK_TRACE                                                 
        rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
40007be8:	e2 07 20 08 	ld  [ %i4 + 8 ], %l1                           <== NOT EXECUTED
40007bec:	40 00 79 ae 	call  400262a4 <strerror>                      <== NOT EXECUTED
40007bf0:	f6 07 20 0c 	ld  [ %i4 + 0xc ], %i3                         <== NOT EXECUTED
40007bf4:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    <== NOT EXECUTED
40007bf8:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
40007bfc:	e4 23 a0 5c 	st  %l2, [ %sp + 0x5c ]                        <== NOT EXECUTED
40007c00:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40007c04:	92 12 63 c8 	or  %o1, 0x3c8, %o1                            <== NOT EXECUTED
40007c08:	94 10 00 11 	mov  %l1, %o2                                  <== NOT EXECUTED
40007c0c:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
40007c10:	7f ff f7 6e 	call  400059c8 <rtems_fdisk_info>              <== NOT EXECUTED
40007c14:	98 10 00 18 	mov  %i0, %o4                                  <== NOT EXECUTED
        {                                                             
          sc->pages_active++;                                         
        }                                                             
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
40007c18:	90 10 00 1d 	mov  %i5, %o0                                  
40007c1c:	7f ff f9 0f 	call  40006058 <rtems_fdisk_queue_segment>     
40007c20:	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)                                                     
40007c24:	c4 07 60 28 	ld  [ %i5 + 0x28 ], %g2                        
40007c28:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
40007c2c:	80 a0 80 01 	cmp  %g2, %g1                                  
40007c30:	1a 80 00 08 	bcc  40007c50 <rtems_fdisk_ioctl+0xe1c>        
40007c34:	80 a4 a0 00 	cmp  %l2, 0                                    
    fd->starvations++;                                                
40007c38:	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);                                     
40007c3c:	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++;                                                
40007c40:	82 00 60 01 	inc  %g1                                       
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
                                                                      
      if (rtems_fdisk_is_erased_blocks_starvation (fd))               
        rtems_fdisk_compact (fd);                                     
40007c44:	7f ff fa d1 	call  40006788 <rtems_fdisk_compact>           
40007c48:	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)                                                        
40007c4c:	80 a4 a0 00 	cmp  %l2, 0                                    
40007c50:	32 80 01 72 	bne,a   40008218 <rtems_fdisk_ioctl+0x13e4>    <== NEVER TAKEN
40007c54:	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)                  
40007c58:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
40007c5c:	b2 06 60 01 	inc  %i1                                       
40007c60:	b4 06 80 01 	add  %i2, %g1, %i2                             
40007c64:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
40007c68:	80 a6 40 01 	cmp  %i1, %g1                                  
40007c6c:	32 bf fe fc 	bne,a   4000785c <rtems_fdisk_ioctl+0xa28>     <== NEVER TAKEN
40007c70:	ee 05 3f f0 	ld  [ %l4 + -16 ], %l7                         <== NOT EXECUTED
40007c74:	c4 07 bf ec 	ld  [ %fp + -20 ], %g2                         
40007c78:	ec 07 bf dc 	ld  [ %fp + -36 ], %l6                         
40007c7c:	f8 00 a0 10 	ld  [ %g2 + 0x10 ], %i4                        
40007c80:	a8 05 20 10 	add  %l4, 0x10, %l4                            
40007c84:	10 bf fe e8 	b  40007824 <rtems_fdisk_ioctl+0x9f0>          
40007c88:	ac 05 a0 01 	inc  %l6                                       
40007c8c:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         <== NOT EXECUTED
40007c90:	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); 
40007c94:	92 10 00 17 	mov  %l7, %o1                                  <== NOT EXECUTED
40007c98:	7f ff f8 48 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40007c9c:	90 12 22 18 	or  %o0, 0x218, %o0                            <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007ca0:	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);                                          
40007ca4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
40007ca8:	9f c0 40 00 	call  %g1                                      
40007cac:	90 10 00 1a 	mov  %i2, %o0                                  
40007cb0:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %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);
40007cb4:	c2 07 bf e0 	ld  [ %fp + -32 ], %g1                         
40007cb8:	84 00 80 15 	add  %g2, %l5, %g2                             
              break;                                                  
40007cbc:	10 bf fd 43 	b  400071c8 <rtems_fdisk_ioctl+0x394>          
40007cc0:	c0 20 40 00 	clr  [ %g1 ]                                   
                                                                      
      return ret;                                                     
    }                                                                 
  }                                                                   
                                                                      
  rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
40007cc4:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           <== NOT EXECUTED
40007cc8:	d4 07 20 0c 	ld  [ %i4 + 0xc ], %o2                         <== NOT EXECUTED
40007ccc:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         <== NOT EXECUTED
40007cd0:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         <== NOT EXECUTED
40007cd4:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40007cd8:	7f ff f8 38 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40007cdc:	90 12 20 40 	or  %o0, 0x40, %o0	! 40035c40 <Callbacks.6428+0x9f8><== NOT EXECUTED
                     sc->device, sc->segment);                        
                                                                      
  sc->failed = true;                                                  
40007ce0:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
  rtems_fdisk_queue_segment (fd, sc);                                 
40007ce4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40007ce8:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40007cec:	7f ff f8 db 	call  40006058 <rtems_fdisk_queue_segment>     <== NOT EXECUTED
40007cf0:	c2 27 20 28 	st  %g1, [ %i4 + 0x28 ]                        <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007cf4:	10 bf ff ec 	b  40007ca4 <rtems_fdisk_ioctl+0xe70>          <== NOT EXECUTED
40007cf8:	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,                       
40007cfc:	90 10 00 1d 	mov  %i5, %o0                                  
40007d00:	92 10 00 1c 	mov  %i4, %o1                                  
40007d04:	94 10 00 15 	mov  %l5, %o2                                  
40007d08:	96 06 20 02 	add  %i0, 2, %o3                               
40007d0c:	7f ff f7 b6 	call  40005be4 <rtems_fdisk_seg_write>         
40007d10:	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)                                                          
40007d14:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40007d18:	22 bf ff 40 	be,a   40007a18 <rtems_fdisk_ioctl+0xbe4>      <== ALWAYS TAKEN
40007d1c:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
    {                                                                 
#if RTEMS_FDISK_TRACE                                                 
      rtems_fdisk_info (fd, " write:%02d-%03d-%03d: "      \          
40007d20:	d4 07 20 08 	ld  [ %i4 + 8 ], %o2                           <== NOT EXECUTED
40007d24:	ea 07 20 0c 	ld  [ %i4 + 0xc ], %l5                         <== NOT EXECUTED
40007d28:	f0 04 60 04 	ld  [ %l1 + 4 ], %i0                           <== NOT EXECUTED
40007d2c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40007d30:	40 00 79 5d 	call  400262a4 <strerror>                      <== NOT EXECUTED
40007d34:	d4 27 bf c8 	st  %o2, [ %fp + -56 ]                         <== NOT EXECUTED
40007d38:	d4 07 bf c8 	ld  [ %fp + -56 ], %o2                         <== NOT EXECUTED
40007d3c:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
40007d40:	f6 23 a0 5c 	st  %i3, [ %sp + 0x5c ]                        <== NOT EXECUTED
40007d44:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40007d48:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    <== NOT EXECUTED
40007d4c:	96 10 00 15 	mov  %l5, %o3                                  <== NOT EXECUTED
40007d50:	92 12 63 10 	or  %o1, 0x310, %o1                            <== NOT EXECUTED
40007d54:	7f ff f7 1d 	call  400059c8 <rtems_fdisk_info>              <== NOT EXECUTED
40007d58:	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);                               
40007d5c:	10 bf ff 35 	b  40007a30 <rtems_fdisk_ioctl+0xbfc>          <== NOT EXECUTED
40007d60:	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",
40007d64:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         
40007d68:	da 04 60 04 	ld  [ %l1 + 4 ], %o5                           
40007d6c:	90 10 00 1d 	mov  %i5, %o0                                  
40007d70:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    
40007d74:	94 10 00 17 	mov  %l7, %o2                                  
40007d78:	7f ff f7 14 	call  400059c8 <rtems_fdisk_info>              
40007d7c:	92 12 62 90 	or  %o1, 0x290, %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)                  
40007d80:	10 bf ff b7 	b  40007c5c <rtems_fdisk_ioctl+0xe28>          
40007d84:	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);                        
40007d88:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40007d8c:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40007d90:	7f ff f6 b0 	call  40005850 <rtems_fdisk_queue_status>      <== NOT EXECUTED
40007d94:	94 07 bf f8 	add  %fp, -8, %o2                              <== NOT EXECUTED
    rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",    
40007d98:	d6 07 20 08 	ld  [ %i4 + 8 ], %o3                           <== NOT EXECUTED
40007d9c:	d8 07 20 0c 	ld  [ %i4 + 0xc ], %o4                         <== NOT EXECUTED
40007da0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40007da4:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    <== NOT EXECUTED
40007da8:	94 10 00 17 	mov  %l7, %o2                                  <== NOT EXECUTED
40007dac:	92 12 63 50 	or  %o1, 0x350, %o1                            <== NOT EXECUTED
40007db0:	7f ff f7 06 	call  400059c8 <rtems_fdisk_info>              <== NOT EXECUTED
40007db4:	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++)                      
40007db8:	10 bf ff 3f 	b  40007ab4 <rtems_fdisk_ioctl+0xc80>          <== NOT EXECUTED
40007dbc:	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);     
40007dc0:	92 10 00 1c 	mov  %i4, %o1                                  
40007dc4:	94 10 00 18 	mov  %i0, %o2                                  
40007dc8:	7f ff f7 ad 	call  40005c7c <rtems_fdisk_seg_write_page_desc>
40007dcc:	96 10 00 1b 	mov  %i3, %o3                                  
        if (ret)                                                      
40007dd0:	a4 92 20 00 	orcc  %o0, 0, %l2                              
40007dd4:	32 80 00 19 	bne,a   40007e38 <rtems_fdisk_ioctl+0x1004>    <== NEVER TAKEN
40007dd8:	e6 07 20 08 	ld  [ %i4 + 8 ], %l3                           <== NOT EXECUTED
                            strerror (ret), ret);                     
#endif                                                                
        }                                                             
        else                                                          
        {                                                             
          sc->pages_active++;                                         
40007ddc:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
40007de0:	82 00 60 01 	inc  %g1                                       
40007de4:	10 bf ff 8d 	b  40007c18 <rtems_fdisk_ioctl+0xde4>          
40007de8:	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;                                                
40007dec:	10 bf ff 2a 	b  40007a94 <rtems_fdisk_ioctl+0xc60>          
40007df0:	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);                                         
40007df4:	7f ff fa 65 	call  40006788 <rtems_fdisk_compact>           
40007df8:	90 10 00 1d 	mov  %i5, %o0                                  
40007dfc:	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)                                                    
40007e00:	80 a7 20 00 	cmp  %i4, 0                                    
40007e04:	32 bf ff 21 	bne,a   40007a88 <rtems_fdisk_ioctl+0xc54>     <== ALWAYS TAKEN
40007e08:	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))                 
40007e0c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           <== NOT EXECUTED
40007e10:	80 88 60 02 	btst  2, %g1                                   <== NOT EXECUTED
40007e14:	12 80 01 06 	bne  4000822c <rtems_fdisk_ioctl+0x13f8>       <== NOT EXECUTED
40007e18:	01 00 00 00 	nop                                            <== NOT EXECUTED
40007e1c:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         <== NOT EXECUTED
40007e20:	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");          
40007e24:	11 10 00 d7 	sethi  %hi(0x40035c00), %o0                    <== NOT EXECUTED
40007e28:	7f ff f7 e4 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40007e2c:	90 12 22 88 	or  %o0, 0x288, %o0	! 40035e88 <Callbacks.6428+0xc40><== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007e30:	10 bf ff 9d 	b  40007ca4 <rtems_fdisk_ioctl+0xe70>          <== NOT EXECUTED
40007e34:	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: "  \     
40007e38:	f0 07 20 0c 	ld  [ %i4 + 0xc ], %i0                         <== NOT EXECUTED
40007e3c:	40 00 79 1a 	call  400262a4 <strerror>                      <== NOT EXECUTED
40007e40:	f6 04 60 04 	ld  [ %l1 + 4 ], %i3                           <== NOT EXECUTED
40007e44:	13 10 00 d7 	sethi  %hi(0x40035c00), %o1                    <== NOT EXECUTED
40007e48:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
40007e4c:	e4 23 a0 5c 	st  %l2, [ %sp + 0x5c ]                        <== NOT EXECUTED
40007e50:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40007e54:	92 12 60 00 	mov  %o1, %o1                                  <== NOT EXECUTED
40007e58:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
40007e5c:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
40007e60:	7f ff f6 da 	call  400059c8 <rtems_fdisk_info>              <== NOT EXECUTED
40007e64:	98 10 00 1b 	mov  %i3, %o4                                  <== NOT EXECUTED
        {                                                             
          sc->pages_active++;                                         
        }                                                             
      }                                                               
                                                                      
      rtems_fdisk_queue_segment (fd, sc);                             
40007e68:	10 bf ff 6d 	b  40007c1c <rtems_fdisk_ioctl+0xde8>          <== NOT EXECUTED
40007e6c:	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: " \    
40007e70:	05 10 00 d5 	sethi  %hi(0x40035400), %g2                    
40007e74:	10 bf ff 44 	b  40007b84 <rtems_fdisk_ioctl+0xd50>          
40007e78:	84 10 a0 70 	or  %g2, 0x70, %g2	! 40035470 <Callbacks.6428+0x228>
 * 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;                                               
40007e7c:	84 10 3f ff 	mov  -1, %g2                                   <== NOT EXECUTED
  uint32_t i;                                                         
                                                                      
  for (i = 0; i < page_size; i++, buffer++)                           
40007e80:	10 bf ff 30 	b  40007b40 <rtems_fdisk_ioctl+0xd0c>          <== NOT EXECUTED
40007e84:	c2 02 a3 24 	ld  [ %o2 + 0x324 ], %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,
40007e88:	19 10 00 d6 	sethi  %hi(0x40035800), %o4                    
40007e8c:	10 bf fd 90 	b  400074cc <rtems_fdisk_ioctl+0x698>          
40007e90:	98 13 20 78 	or  %o4, 0x78, %o4	! 40035878 <Callbacks.6428+0x630>
        else                                                          
        {                                                             
          switch (r->req)                                             
          {                                                           
            case RTEMS_BLKDEV_REQ_READ:                               
              errno = rtems_fdisk_read (&rtems_flashdisks[minor], r); 
40007e94:	40 00 6f 29 	call  40023b38 <__errno>                       
40007e98:	b0 06 a0 18 	add  %i2, 0x18, %i0                            
40007e9c:	f8 04 23 70 	ld  [ %l0 + 0x370 ], %i4                       
40007ea0:	fa 06 a0 10 	ld  [ %i2 + 0x10 ], %i5                        
40007ea4:	d0 27 bf e8 	st  %o0, [ %fp + -24 ]                         
40007ea8:	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++)       
40007eac:	a6 10 20 00 	clr  %l3                                       
40007eb0:	ea 27 bf ec 	st  %l5, [ %fp + -20 ]                         
40007eb4:	80 a4 c0 1d 	cmp  %l3, %i5                                  
40007eb8:	1a 80 00 a5 	bcc  4000814c <rtems_fdisk_ioctl+0x1318>       
40007ebc:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         
  {                                                                   
    uint8_t* data;                                                    
    uint32_t fb;                                                      
    uint32_t b;                                                       
    fb = sg->length / fd->block_size;                                 
40007ec0:	d0 06 20 04 	ld  [ %i0 + 4 ], %o0                           
40007ec4:	7f ff e9 f7 	call  400026a0 <.udiv>                         
40007ec8:	d2 07 20 14 	ld  [ %i4 + 0x14 ], %o1                        
    data = sg->buffer;                                                
40007ecc:	f2 06 20 08 	ld  [ %i0 + 8 ], %i1                           
    for (b = 0; b < fb; b++, data += fd->block_size)                  
40007ed0:	80 a2 20 00 	cmp  %o0, 0                                    
40007ed4:	02 80 00 9b 	be  40008140 <rtems_fdisk_ioctl+0x130c>        <== NEVER TAKEN
40007ed8:	a8 10 00 08 	mov  %o0, %l4                                  
40007edc:	a4 10 20 00 	clr  %l2                                       
    {                                                                 
      ret = rtems_fdisk_read_block (fd, sg->block + b, data);         
40007ee0:	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);                      
40007ee4:	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);         
40007ee8:	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);                      
40007eec:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    
40007ef0:	94 10 00 1b 	mov  %i3, %o2                                  
40007ef4:	7f ff f6 b5 	call  400059c8 <rtems_fdisk_info>              
40007ef8:	92 12 60 88 	or  %o1, 0x88, %o1                             
                                                                      
  /*                                                                  
   * Broken out to allow info messages when testing.                  
   */                                                                 
                                                                      
  if (block >= (fd->block_count - fd->unavail_blocks))                
40007efc:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
40007f00:	c2 07 20 20 	ld  [ %i4 + 0x20 ], %g1                        
40007f04:	82 20 80 01 	sub  %g2, %g1, %g1                             
40007f08:	80 a6 c0 01 	cmp  %i3, %g1                                  
40007f0c:	1a 80 00 74 	bcc  400080dc <rtems_fdisk_ioctl+0x12a8>       <== NEVER TAKEN
40007f10:	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];                                            
40007f14:	ea 07 20 18 	ld  [ %i4 + 0x18 ], %l5                        
                                                                      
  if (!bc->segment)                                                   
40007f18:	fa 05 40 01 	ld  [ %l5 + %g1 ], %i5                         
40007f1c:	80 a7 60 00 	cmp  %i5, 0                                    
40007f20:	02 80 00 79 	be  40008104 <rtems_fdisk_ioctl+0x12d0>        
40007f24:	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];                               
40007f28:	da 05 60 04 	ld  [ %l5 + 4 ], %o5                           
40007f2c:	ec 07 60 10 	ld  [ %i5 + 0x10 ], %l6                        
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
40007f30:	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];                               
40007f34:	a3 2b 60 03 	sll  %o5, 3, %l1                               
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
40007f38:	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];                               
40007f3c:	ae 05 80 11 	add  %l6, %l1, %l7                             
                                                                      
#if RTEMS_FDISK_TRACE                                                 
  rtems_fdisk_info (fd,                                               
40007f40:	d8 07 60 0c 	ld  [ %i5 + 0xc ], %o4                         
40007f44:	de 07 60 14 	ld  [ %i5 + 0x14 ], %o7                        
40007f48:	c8 07 60 1c 	ld  [ %i5 + 0x1c ], %g4                        
40007f4c:	c6 07 60 20 	ld  [ %i5 + 0x20 ], %g3                        
40007f50:	80 a0 60 00 	cmp  %g1, 0                                    
40007f54:	02 80 00 69 	be  400080f8 <rtems_fdisk_ioctl+0x12c4>        
40007f58:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
40007f5c:	15 10 00 d5 	sethi  %hi(0x40035400), %o2                    
40007f60:	82 12 a0 68 	or  %o2, 0x68, %g1	! 40035468 <Callbacks.6428+0x220>
40007f64:	de 23 a0 5c 	st  %o7, [ %sp + 0x5c ]                        
40007f68:	c8 23 a0 60 	st  %g4, [ %sp + 0x60 ]                        
40007f6c:	c6 23 a0 64 	st  %g3, [ %sp + 0x64 ]                        
40007f70:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
40007f74:	c2 23 a0 6c 	st  %g1, [ %sp + 0x6c ]                        
40007f78:	c2 15 e0 02 	lduh  [ %l7 + 2 ], %g1                         
40007f7c:	90 10 00 1c 	mov  %i4, %o0                                  
40007f80:	c2 23 a0 70 	st  %g1, [ %sp + 0x70 ]                        
40007f84:	c2 15 80 11 	lduh  [ %l6 + %l1 ], %g1                       
40007f88:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    
40007f8c:	c2 23 a0 74 	st  %g1, [ %sp + 0x74 ]                        
40007f90:	c2 05 e0 04 	ld  [ %l7 + 4 ], %g1                           
40007f94:	92 12 60 e8 	or  %o1, 0xe8, %o1                             
40007f98:	c2 23 a0 78 	st  %g1, [ %sp + 0x78 ]                        
40007f9c:	7f ff f6 8b 	call  400059c8 <rtems_fdisk_info>              
40007fa0:	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;                     
40007fa4:	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))  
40007fa8:	80 88 60 01 	btst  1, %g1                                   
40007fac:	12 80 00 15 	bne  40008000 <rtems_fdisk_ioctl+0x11cc>       <== NEVER TAKEN
40007fb0:	80 88 60 02 	btst  2, %g1                                   
  {                                                                   
    if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
40007fb4:	12 80 00 1e 	bne  4000802c <rtems_fdisk_ioctl+0x11f8>       <== ALWAYS TAKEN
40007fb8:	92 10 00 1b 	mov  %i3, %o1                                  
40007fbc:	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",
40007fc0:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           <== NOT EXECUTED
40007fc4:	d6 07 60 0c 	ld  [ %i5 + 0xc ], %o3                         <== NOT EXECUTED
40007fc8:	d8 04 60 04 	ld  [ %l1 + 4 ], %o4                           <== NOT EXECUTED
40007fcc:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
40007fd0:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         <== NOT EXECUTED
40007fd4:	7f ff f7 79 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40007fd8:	90 12 21 a0 	or  %o0, 0x1a0, %o0                            <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40007fdc:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
40007fe0:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
40007fe4:	9f c0 40 00 	call  %g1                                      
40007fe8:	90 10 00 1a 	mov  %i2, %o0                                  
40007fec:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       
        else                                                          
        {                                                             
          switch (r->req)                                             
          {                                                           
            case RTEMS_BLKDEV_REQ_READ:                               
              errno = rtems_fdisk_read (&rtems_flashdisks[minor], r); 
40007ff0:	c2 07 bf e8 	ld  [ %fp + -24 ], %g1                         
40007ff4:	84 00 80 15 	add  %g2, %l5, %g2                             
              break;                                                  
40007ff8:	10 bf fc 74 	b  400071c8 <rtems_fdisk_ioctl+0x394>          
40007ffc:	c0 20 40 00 	clr  [ %g1 ]                                   
40008000:	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",
40008004:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           <== NOT EXECUTED
40008008:	d6 07 60 0c 	ld  [ %i5 + 0xc ], %o3                         <== NOT EXECUTED
4000800c:	d8 04 60 04 	ld  [ %l1 + 4 ], %o4                           <== NOT EXECUTED
40008010:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         <== NOT EXECUTED
40008014:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40008018:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
4000801c:	7f ff f7 67 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40008020:	90 12 21 d8 	or  %o0, 0x1d8, %o0	! 400359d8 <Callbacks.6428+0x790><== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40008024:	10 bf ff ef 	b  40007fe0 <rtems_fdisk_ioctl+0x11ac>         <== NOT EXECUTED
40008028:	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);
4000802c:	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,                    
40008030:	c2 05 60 04 	ld  [ %l5 + 4 ], %g1                           
40008034:	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,                                
40008038:	92 10 00 17 	mov  %l7, %o1                                  
4000803c:	7f ff e9 5f 	call  400025b8 <.umul>                         
40008040:	90 02 00 01 	add  %o0, %g1, %o0                             
40008044:	92 10 00 1d 	mov  %i5, %o1                                  
40008048:	94 10 00 08 	mov  %o0, %o2                                  
4000804c:	96 10 00 19 	mov  %i1, %o3                                  
40008050:	90 10 00 1c 	mov  %i4, %o0                                  
40008054:	7f ff f6 a1 	call  40005ad8 <rtems_fdisk_seg_read>          
40008058:	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)                                                        
4000805c:	84 92 20 00 	orcc  %o0, 0, %g2                              
40008060:	32 80 00 3d 	bne,a   40008154 <rtems_fdisk_ioctl+0x1320>    <== NEVER TAKEN
40008064:	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);        
40008068:	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++)                           
4000806c:	80 a0 60 00 	cmp  %g1, 0                                    
40008070:	22 80 00 0f 	be,a   400080ac <rtems_fdisk_ioctl+0x1278>     <== NEVER TAKEN
40008074:	84 10 3f ff 	mov  -1, %g2                                   <== NOT EXECUTED
40008078:	05 10 01 2a 	sethi  %hi(0x4004a800), %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)   
4000807c:	88 06 40 01 	add  %i1, %g1, %g4                             
40008080:	fa 00 a3 78 	ld  [ %g2 + 0x378 ], %i5                       
40008084:	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;                                               
40008088:	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);                        
4000808c:	de 08 c0 00 	ldub  [ %g3 ], %o7                             
40008090:	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++)                           
40008094:	86 00 e0 01 	inc  %g3                                       
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
40008098:	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++)                           
4000809c:	80 a0 c0 04 	cmp  %g3, %g4                                  
    cs = rtems_fdisk_calc_crc16 (cs, *buffer);                        
400080a0:	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++)                           
400080a4:	12 bf ff fa 	bne  4000808c <rtems_fdisk_ioctl+0x1258>       
400080a8:	c4 17 40 02 	lduh  [ %i5 + %g2 ], %g2                       
        return ret;                                                   
      }                                                               
                                                                      
      cs = rtems_fdisk_page_checksum (buffer, fd->block_size);        
                                                                      
      if (cs == pd->crc)                                              
400080ac:	d6 15 80 11 	lduh  [ %l6 + %l1 ], %o3                       
400080b0:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
400080b4:	95 30 a0 10 	srl  %g2, 0x10, %o2                            
400080b8:	80 a2 80 0b 	cmp  %o2, %o3                                  
400080bc:	02 80 00 1c 	be  4000812c <rtems_fdisk_ioctl+0x12f8>        <== ALWAYS TAKEN
400080c0:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         
        return 0;                                                     
                                                                      
      rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
400080c4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
400080c8:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
400080cc:	7f ff f7 3b 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
400080d0:	90 12 21 68 	or  %o0, 0x168, %o0	! 40035968 <Callbacks.6428+0x720><== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
400080d4:	10 bf ff c3 	b  40007fe0 <rtems_fdisk_ioctl+0x11ac>         <== NOT EXECUTED
400080d8:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
400080dc:	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);  
400080e0:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
400080e4:	11 10 00 d6 	sethi  %hi(0x40035800), %o0                    <== NOT EXECUTED
400080e8:	7f ff f7 34 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
400080ec:	90 12 20 98 	or  %o0, 0x98, %o0	! 40035898 <Callbacks.6428+0x650><== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
400080f0:	10 bf ff bc 	b  40007fe0 <rtems_fdisk_ioctl+0x11ac>         <== NOT EXECUTED
400080f4:	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,                                               
400080f8:	15 10 00 d5 	sethi  %hi(0x40035400), %o2                    
400080fc:	10 bf ff 9a 	b  40007f64 <rtems_fdisk_ioctl+0x1130>         
40008100:	82 12 a0 70 	or  %o2, 0x70, %g1	! 40035470 <Callbacks.6428+0x228>
  bc = &fd->blocks[block];                                            
                                                                      
  if (!bc->segment)                                                   
  {                                                                   
#if RTEMS_FDISK_TRACE                                                 
    rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
40008104:	94 10 00 1b 	mov  %i3, %o2                                  
40008108:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    
4000810c:	90 10 00 1c 	mov  %i4, %o0                                  
40008110:	7f ff f6 2e 	call  400059c8 <rtems_fdisk_info>              
40008114:	92 12 60 c0 	or  %o1, 0xc0, %o1                             
#endif                                                                
    memset (buffer, 0xff, fd->block_size);                            
40008118:	d4 07 20 14 	ld  [ %i4 + 0x14 ], %o2                        
4000811c:	90 10 00 19 	mov  %i1, %o0                                  
40008120:	40 00 73 99 	call  40024f84 <memset>                        
40008124:	92 10 20 ff 	mov  0xff, %o1                                 
40008128:	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)                  
4000812c:	a4 04 a0 01 	inc  %l2                                       
40008130:	80 a4 80 14 	cmp  %l2, %l4                                  
40008134:	12 bf ff 6b 	bne  40007ee0 <rtems_fdisk_ioctl+0x10ac>       <== NEVER TAKEN
40008138:	b2 06 40 01 	add  %i1, %g1, %i1                             
4000813c:	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++)       
40008140:	a6 04 e0 01 	inc  %l3                                       
40008144:	10 bf ff 5c 	b  40007eb4 <rtems_fdisk_ioctl+0x1080>         
40008148:	b0 06 20 10 	add  %i0, 0x10, %i0                            
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
4000814c:	10 bf ff a5 	b  40007fe0 <rtems_fdisk_ioctl+0x11ac>         
40008150:	92 10 20 00 	clr  %o1                                       
                                           bc->page + sc->pages_desc, buffer);
                                                                      
      if (ret)                                                        
      {                                                               
#if RTEMS_FDISK_TRACE                                                 
        rtems_fdisk_info (fd,                                         
40008154:	f6 07 60 0c 	ld  [ %i5 + 0xc ], %i3                         <== NOT EXECUTED
40008158:	a2 10 00 15 	mov  %l5, %l1                                  <== NOT EXECUTED
4000815c:	ea 07 bf ec 	ld  [ %fp + -20 ], %l5                         <== NOT EXECUTED
40008160:	fa 04 60 04 	ld  [ %l1 + 4 ], %i5                           <== NOT EXECUTED
40008164:	40 00 78 50 	call  400262a4 <strerror>                      <== NOT EXECUTED
40008168:	c4 27 bf d0 	st  %g2, [ %fp + -48 ]                         <== NOT EXECUTED
4000816c:	c4 07 bf d0 	ld  [ %fp + -48 ], %g2                         <== NOT EXECUTED
40008170:	9a 10 00 08 	mov  %o0, %o5                                  <== NOT EXECUTED
40008174:	c4 23 a0 5c 	st  %g2, [ %sp + 0x5c ]                        <== NOT EXECUTED
40008178:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4000817c:	13 10 00 d6 	sethi  %hi(0x40035800), %o1                    <== NOT EXECUTED
40008180:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
40008184:	92 12 61 30 	or  %o1, 0x130, %o1                            <== NOT EXECUTED
40008188:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
4000818c:	7f ff f6 0f 	call  400059c8 <rtems_fdisk_info>              <== NOT EXECUTED
40008190:	98 10 00 1d 	mov  %i5, %o4                                  <== NOT EXECUTED
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40008194:	10 bf ff 93 	b  40007fe0 <rtems_fdisk_ioctl+0x11ac>         <== NOT EXECUTED
40008198:	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++)             
4000819c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400081a0:	02 bf fc 59 	be  40007304 <rtems_fdisk_ioctl+0x4d0>         <== NOT EXECUTED
400081a4:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       <== NOT EXECUTED
    {                                                                 
      if (!fd->devices[device].segments)                              
400081a8:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        <== NOT EXECUTED
400081ac:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
400081b0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400081b4:	02 bf fc 54 	be  40007304 <rtems_fdisk_ioctl+0x4d0>         <== NOT EXECUTED
400081b8:	90 10 20 0c 	mov  0xc, %o0                                  <== NOT EXECUTED
400081bc:	b6 10 20 0c 	mov  0xc, %i3                                  <== NOT EXECUTED
400081c0:	10 80 00 0b 	b  400081ec <rtems_fdisk_ioctl+0x13b8>         <== NOT EXECUTED
400081c4:	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++)             
400081c8:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
400081cc:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
400081d0:	1a bf fc 4d 	bcc  40007304 <rtems_fdisk_ioctl+0x4d0>        <== NOT EXECUTED
400081d4:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       <== NOT EXECUTED
    {                                                                 
      if (!fd->devices[device].segments)                              
400081d8:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        <== NOT EXECUTED
400081dc:	c2 00 40 1b 	ld  [ %g1 + %i3 ], %g1                         <== NOT EXECUTED
400081e0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400081e4:	02 80 00 0b 	be  40008210 <rtems_fdisk_ioctl+0x13dc>        <== NOT EXECUTED
400081e8:	b6 06 e0 0c 	add  %i3, 0xc, %i3                             <== NOT EXECUTED
        return ENOMEM;                                                
                                                                      
      ret = rtems_fdisk_recover_block_mappings (fd);                  
400081ec:	7f ff fa 1d 	call  40006a60 <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
400081f0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      if (ret)                                                        
400081f4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400081f8:	22 bf ff f4 	be,a   400081c8 <rtems_fdisk_ioctl+0x1394>     <== NOT EXECUTED
400081fc:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        <== NOT EXECUTED
40008200:	10 bf fc 41 	b  40007304 <rtems_fdisk_ioctl+0x4d0>          <== NOT EXECUTED
40008204:	c4 04 23 70 	ld  [ %l0 + 0x370 ], %g2                       <== NOT EXECUTED
 */                                                                   
static int                                                            
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)                   
{                                                                     
  uint32_t device;                                                    
  for (device = 0; device < fd->device_count; device++)               
40008208:	10 bf fc 3e 	b  40007300 <rtems_fdisk_ioctl+0x4cc>          <== NOT EXECUTED
4000820c:	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;                                                
40008210:	10 bf fc 3c 	b  40007300 <rtems_fdisk_ioctl+0x4cc>          <== NOT EXECUTED
40008214:	90 10 20 0c 	mov  0xc, %o0                                  <== NOT EXECUTED
40008218:	10 bf fe a2 	b  40007ca0 <rtems_fdisk_ioctl+0xe6c>          <== NOT EXECUTED
4000821c:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         <== NOT EXECUTED
40008220:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         
      if (ret)                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_blkdev_request_done (req, ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL);
40008224:	10 bf fe a0 	b  40007ca4 <rtems_fdisk_ioctl+0xe70>          
40008228:	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);                                       
4000822c:	7f ff f9 57 	call  40006788 <rtems_fdisk_compact>           <== NOT EXECUTED
40008230:	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)                                                    
40008234:	f8 07 60 34 	ld  [ %i5 + 0x34 ], %i4                        <== NOT EXECUTED
40008238:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4000823c:	32 bf fe 13 	bne,a   40007a88 <rtems_fdisk_ioctl+0xc54>     <== NOT EXECUTED
40008240:	c2 07 00 00 	ld  [ %i4 ], %g1                               <== NOT EXECUTED
40008244:	10 bf fe f7 	b  40007e20 <rtems_fdisk_ioctl+0xfec>          <== NOT EXECUTED
40008248:	f4 07 bf ec 	ld  [ %fp + -20 ], %i2                         <== NOT EXECUTED
                                                                      

40006058 <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) {
40006058:	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",
4000605c:	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)
{                                                                     
40006060:	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",
40006064:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
40006068:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         
4000606c:	d8 06 60 14 	ld  [ %i1 + 0x14 ], %o4                        
40006070:	da 06 60 1c 	ld  [ %i1 + 0x1c ], %o5                        
40006074:	c8 06 60 20 	ld  [ %i1 + 0x20 ], %g4                        
40006078:	80 a0 60 00 	cmp  %g1, 0                                    
4000607c:	02 80 00 2b 	be  40006128 <rtems_fdisk_queue_segment+0xd0>  <== ALWAYS TAKEN
40006080:	c6 06 60 24 	ld  [ %i1 + 0x24 ], %g3                        
40006084:	c4 06 80 00 	ld  [ %i2 ], %g2                               <== NOT EXECUTED
40006088:	03 10 00 d5 	sethi  %hi(0x40035400), %g1                    <== NOT EXECUTED
4000608c:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40006090:	02 80 00 2b 	be  4000613c <rtems_fdisk_queue_segment+0xe4>  <== NOT EXECUTED
40006094:	82 10 60 58 	or  %g1, 0x58, %g1                             <== NOT EXECUTED
40006098:	05 10 00 d5 	sethi  %hi(0x40035400), %g2                    
4000609c:	84 10 a0 68 	or  %g2, 0x68, %g2	! 40035468 <Callbacks.6428+0x220>
400060a0:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
400060a4:	c8 23 a0 5c 	st  %g4, [ %sp + 0x5c ]                        
400060a8:	c6 23 a0 60 	st  %g3, [ %sp + 0x60 ]                        
400060ac:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
400060b0:	90 10 00 18 	mov  %i0, %o0                                  
400060b4:	13 10 00 d5 	sethi  %hi(0x40035400), %o1                    
400060b8:	7f ff fe 44 	call  400059c8 <rtems_fdisk_info>              
400060bc:	92 12 60 78 	or  %o1, 0x78, %o1	! 40035478 <Callbacks.6428+0x230>
                                                                      
  /*                                                                  
   * If the segment has failed then check the failed queue and append 
   * if not failed.                                                   
   */                                                                 
  if (sc->failed)                                                     
400060c0:	c2 06 a0 28 	ld  [ %i2 + 0x28 ], %g1                        
400060c4:	80 a0 60 00 	cmp  %g1, 0                                    
400060c8:	22 80 00 2c 	be,a   40006178 <rtems_fdisk_queue_segment+0x120><== ALWAYS TAKEN
400060cc:	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;                         
400060d0:	c2 06 20 58 	ld  [ %i0 + 0x58 ], %g1                        <== NOT EXECUTED
                                                                      
  while (it)                                                          
400060d4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400060d8:	02 80 00 89 	be  400062fc <rtems_fdisk_queue_segment+0x2a4> <== NOT EXECUTED
400060dc:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
  {                                                                   
    if (it == sc)                                                     
400060e0:	32 80 00 06 	bne,a   400060f8 <rtems_fdisk_queue_segment+0xa0><== NOT EXECUTED
400060e4:	c2 00 40 00 	ld  [ %g1 ], %g1                               <== NOT EXECUTED
400060e8:	30 80 00 89 	b,a   4000630c <rtems_fdisk_queue_segment+0x2b4><== NOT EXECUTED
400060ec:	02 80 00 88 	be  4000630c <rtems_fdisk_queue_segment+0x2b4> <== NOT EXECUTED
400060f0:	01 00 00 00 	nop                                            <== NOT EXECUTED
      return true;                                                    
    it = it->next;                                                    
400060f4:	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)                                                          
400060f8:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400060fc:	12 bf ff fc 	bne  400060ec <rtems_fdisk_queue_segment+0x94> <== NOT EXECUTED
40006100:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40006104:	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;                                                     
40006108:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
4000610c:	f4 20 40 00 	st  %i2, [ %g1 ]                               <== NOT EXECUTED
      queue->tail       = sc;                                         
40006110:	f4 26 20 5c 	st  %i2, [ %i0 + 0x5c ]                        <== NOT EXECUTED
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40006114:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        <== NOT EXECUTED
40006118:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
4000611c:	c2 26 20 60 	st  %g1, [ %i0 + 0x60 ]                        <== NOT EXECUTED
40006120:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006124:	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",
40006128:	c4 06 80 00 	ld  [ %i2 ], %g2                               
4000612c:	03 10 00 d5 	sethi  %hi(0x40035400), %g1                    
40006130:	80 a0 a0 00 	cmp  %g2, 0                                    
40006134:	12 bf ff d9 	bne  40006098 <rtems_fdisk_queue_segment+0x40> 
40006138:	82 10 60 60 	or  %g1, 0x60, %g1                             
4000613c:	05 10 00 d5 	sethi  %hi(0x40035400), %g2                    
40006140:	84 10 a0 70 	or  %g2, 0x70, %g2	! 40035470 <Callbacks.6428+0x228>
40006144:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
40006148:	c8 23 a0 5c 	st  %g4, [ %sp + 0x5c ]                        
4000614c:	c6 23 a0 60 	st  %g3, [ %sp + 0x60 ]                        
40006150:	c4 23 a0 68 	st  %g2, [ %sp + 0x68 ]                        
40006154:	90 10 00 18 	mov  %i0, %o0                                  
40006158:	13 10 00 d5 	sethi  %hi(0x40035400), %o1                    
4000615c:	7f ff fe 1b 	call  400059c8 <rtems_fdisk_info>              
40006160:	92 12 60 78 	or  %o1, 0x78, %o1	! 40035478 <Callbacks.6428+0x230>
                                                                      
  /*                                                                  
   * If the segment has failed then check the failed queue and append 
   * if not failed.                                                   
   */                                                                 
  if (sc->failed)                                                     
40006164:	c2 06 a0 28 	ld  [ %i2 + 0x28 ], %g1                        
40006168:	80 a0 60 00 	cmp  %g1, 0                                    
4000616c:	32 bf ff da 	bne,a   400060d4 <rtems_fdisk_queue_segment+0x7c><== NEVER TAKEN
40006170:	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);              
40006174:	92 10 00 1a 	mov  %i2, %o1                                  
40006178:	b8 06 20 34 	add  %i0, 0x34, %i4                            
4000617c:	7f ff fd 94 	call  400057cc <rtems_fdisk_segment_queue_remove>
40006180:	90 10 00 1c 	mov  %i4, %o0                                  
  rtems_fdisk_segment_queue_remove (&fd->used, sc);                   
40006184:	b6 06 20 40 	add  %i0, 0x40, %i3                            
40006188:	92 10 00 1a 	mov  %i2, %o1                                  
4000618c:	7f ff fd 90 	call  400057cc <rtems_fdisk_segment_queue_remove>
40006190:	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);
40006194:	c6 06 a0 1c 	ld  [ %i2 + 0x1c ], %g3                        
40006198:	fa 06 a0 14 	ld  [ %i2 + 0x14 ], %i5                        
4000619c:	c2 06 a0 20 	ld  [ %i2 + 0x20 ], %g1                        
400061a0:	c4 06 a0 24 	ld  [ %i2 + 0x24 ], %g2                        
400061a4:	88 00 40 03 	add  %g1, %g3, %g4                             
400061a8:	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)                      
400061ac:	80 a7 40 02 	cmp  %i5, %g2                                  
400061b0:	02 80 00 29 	be  40006254 <rtems_fdisk_queue_segment+0x1fc> 
400061b4:	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;                
400061b8:	f2 06 20 34 	ld  [ %i0 + 0x34 ], %i1                        
                                                                      
    while (seg)                                                       
400061bc:	80 a6 60 00 	cmp  %i1, 0                                    
400061c0:	22 80 00 57 	be,a   4000631c <rtems_fdisk_queue_segment+0x2c4>
400061c4:	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)
400061c8:	f6 06 60 20 	ld  [ %i1 + 0x20 ], %i3                        
400061cc:	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);
400061d0:	c8 06 60 14 	ld  [ %i1 + 0x14 ], %g4                        
400061d4:	c6 06 60 1c 	ld  [ %i1 + 0x1c ], %g3                        
400061d8:	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)
400061dc:	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);
400061e0:	82 21 00 01 	sub  %g4, %g1, %g1                             
400061e4:	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) <                      
400061e8:	80 a7 40 01 	cmp  %i5, %g1                                  
400061ec:	3a 80 00 0e 	bcc,a   40006224 <rtems_fdisk_queue_segment+0x1cc>
400061f0:	f2 06 40 00 	ld  [ %i1 ], %i1                               
        break;                                                        
      seg = seg->next;                                                
    }                                                                 
                                                                      
    if (seg)                                                          
      rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
400061f4:	7f ff ff 6f 	call  40005fb0 <rtems_fdisk_segment_queue_insert_before>
400061f8:	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)
400061fc:	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);
40006200:	c6 06 60 14 	ld  [ %i1 + 0x14 ], %g3                        
40006204:	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)
40006208:	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);
4000620c:	82 20 c0 01 	sub  %g3, %g1, %g1                             
40006210:	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) <                      
40006214:	80 a7 40 01 	cmp  %i5, %g1                                  
40006218:	0a bf ff f7 	bcs  400061f4 <rtems_fdisk_queue_segment+0x19c><== NEVER TAKEN
4000621c:	01 00 00 00 	nop                                            
          rtems_fdisk_seg_pages_available (seg))                      
        break;                                                        
      seg = seg->next;                                                
40006220:	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)                                                       
40006224:	80 a6 60 00 	cmp  %i1, 0                                    
40006228:	32 bf ff f5 	bne,a   400061fc <rtems_fdisk_queue_segment+0x1a4>
4000622c:	c8 06 60 24 	ld  [ %i1 + 0x24 ], %g4                        
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40006230:	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;                                                     
40006234:	c0 26 80 00 	clr  [ %i2 ]                                   
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
40006238:	f4 20 40 00 	st  %i2, [ %g1 ]                               
      queue->tail       = sc;                                         
4000623c:	f4 26 20 38 	st  %i2, [ %i0 + 0x38 ]                        
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40006240:	c2 06 20 3c 	ld  [ %i0 + 0x3c ], %g1                        
40006244:	82 00 60 01 	inc  %g1                                       
40006248:	c2 26 20 3c 	st  %g1, [ %i0 + 0x3c ]                        
4000624c:	81 c7 e0 08 	ret                                            
40006250:	81 e8 00 00 	restore                                        
   * to background erase perform the erase now.                       
   *                                                                  
   */                                                                 
  if (rtems_fdisk_seg_pages_available (sc) == 0)                      
  {                                                                   
    if (sc->pages_active)                                             
40006254:	22 80 00 1b 	be,a   400062c0 <rtems_fdisk_queue_segment+0x268><== NEVER TAKEN
40006258:	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;                   
4000625c:	f2 06 20 40 	ld  [ %i0 + 0x40 ], %i1                        
                                                                      
      while (seg)                                                     
40006260:	80 a6 60 00 	cmp  %i1, 0                                    
40006264:	22 80 00 36 	be,a   4000633c <rtems_fdisk_queue_segment+0x2e4>
40006268:	c0 26 80 00 	clr  [ %i2 ]                                   
      {                                                               
        if (sc->pages_used > seg->pages_used)                         
4000626c:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
40006270:	80 a0 40 02 	cmp  %g1, %g2                                  
40006274:	28 80 00 07 	bleu,a   40006290 <rtems_fdisk_queue_segment+0x238>
40006278:	f2 06 40 00 	ld  [ %i1 ], %i1                               
4000627c:	30 80 00 26 	b,a   40006314 <rtems_fdisk_queue_segment+0x2bc>
40006280:	80 a0 80 01 	cmp  %g2, %g1                                  
40006284:	0a 80 00 24 	bcs  40006314 <rtems_fdisk_queue_segment+0x2bc>
40006288:	01 00 00 00 	nop                                            
          break;                                                      
        seg = seg->next;                                              
4000628c:	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)                                                     
40006290:	80 a6 60 00 	cmp  %i1, 0                                    
40006294:	32 bf ff fb 	bne,a   40006280 <rtems_fdisk_queue_segment+0x228>
40006298:	c4 06 60 20 	ld  [ %i1 + 0x20 ], %g2                        
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
4000629c:	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;                                                     
400062a0:	c0 26 80 00 	clr  [ %i2 ]                                   
                                                                      
    if (queue->head)                                                  
    {                                                                 
      queue->tail->next = sc;                                         
400062a4:	f4 20 40 00 	st  %i2, [ %g1 ]                               
      queue->tail       = sc;                                         
400062a8:	f4 26 20 44 	st  %i2, [ %i0 + 0x44 ]                        
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
400062ac:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        
400062b0:	82 00 60 01 	inc  %g1                                       
400062b4:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        
400062b8:	81 c7 e0 08 	ret                                            
400062bc:	81 e8 00 00 	restore                                        
      else                                                            
        rtems_fdisk_segment_queue_push_tail (&fd->used, sc);          
    }                                                                 
    else                                                              
    {                                                                 
      if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))                 
400062c0:	80 88 60 01 	btst  1, %g1                                   <== NOT EXECUTED
400062c4:	02 80 00 19 	be  40006328 <rtems_fdisk_queue_segment+0x2d0> <== NOT EXECUTED
400062c8:	01 00 00 00 	nop                                            <== NOT EXECUTED
{                                                                     
  if (sc)                                                             
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
400062cc:	c2 06 20 4c 	ld  [ %i0 + 0x4c ], %g1                        <== NOT EXECUTED
400062d0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400062d4:	02 80 00 17 	be  40006330 <rtems_fdisk_queue_segment+0x2d8> <== NOT EXECUTED
400062d8:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
    {                                                                 
      queue->tail->next = sc;                                         
400062dc:	c2 06 20 50 	ld  [ %i0 + 0x50 ], %g1                        <== NOT EXECUTED
400062e0:	f4 20 40 00 	st  %i2, [ %g1 ]                               <== NOT EXECUTED
      queue->tail       = sc;                                         
400062e4:	f4 26 20 50 	st  %i2, [ %i0 + 0x50 ]                        <== NOT EXECUTED
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
400062e8:	c2 06 20 54 	ld  [ %i0 + 0x54 ], %g1                        <== NOT EXECUTED
400062ec:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
400062f0:	c2 26 20 54 	st  %g1, [ %i0 + 0x54 ]                        <== NOT EXECUTED
400062f4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400062f8:	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;                                                     
400062fc:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
40006300:	f4 26 20 5c 	st  %i2, [ %i0 + 0x5c ]                        <== NOT EXECUTED
40006304:	10 bf ff 84 	b  40006114 <rtems_fdisk_queue_segment+0xbc>   <== NOT EXECUTED
40006308:	f4 26 20 58 	st  %i2, [ %i0 + 0x58 ]                        <== NOT EXECUTED
4000630c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006310:	81 e8 00 00 	restore                                        <== NOT EXECUTED
          break;                                                      
        seg = seg->next;                                              
      }                                                               
                                                                      
      if (seg)                                                        
        rtems_fdisk_segment_queue_insert_before (&fd->used, seg, sc); 
40006314:	7f ff ff 27 	call  40005fb0 <rtems_fdisk_segment_queue_insert_before>
40006318:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
4000631c:	f4 26 20 38 	st  %i2, [ %i0 + 0x38 ]                        
40006320:	10 bf ff c8 	b  40006240 <rtems_fdisk_queue_segment+0x1e8>  
40006324:	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);                           
40006328:	7f ff fe c3 	call  40005e34 <rtems_fdisk_erase_segment>     <== NOT EXECUTED
4000632c:	93 e8 00 1a 	restore  %g0, %i2, %o1                         <== NOT EXECUTED
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
40006330:	f4 26 20 50 	st  %i2, [ %i0 + 0x50 ]                        <== NOT EXECUTED
40006334:	10 bf ff ed 	b  400062e8 <rtems_fdisk_queue_segment+0x290>  <== NOT EXECUTED
40006338:	f4 26 20 4c 	st  %i2, [ %i0 + 0x4c ]                        <== NOT EXECUTED
4000633c:	f4 26 20 44 	st  %i2, [ %i0 + 0x44 ]                        
40006340:	10 bf ff db 	b  400062ac <rtems_fdisk_queue_segment+0x254>  
40006344:	f4 26 20 40 	st  %i2, [ %i0 + 0x40 ]                        
                                                                      

40005850 <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;
40005850:	c2 02 20 34 	ld  [ %o0 + 0x34 ], %g1                        
                                                                      
  while (it)                                                          
40005854:	80 a0 60 00 	cmp  %g1, 0                                    
40005858:	12 80 00 07 	bne  40005874 <rtems_fdisk_queue_status+0x24>  <== ALWAYS TAKEN
4000585c:	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' : '-';
40005860:	10 80 00 0a 	b  40005888 <rtems_fdisk_queue_status+0x38>    <== NOT EXECUTED
40005864:	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)                                                          
40005868:	80 a0 60 00 	cmp  %g1, 0                                    
4000586c:	02 80 00 06 	be  40005884 <rtems_fdisk_queue_status+0x34>   <== ALWAYS TAKEN
40005870:	80 a2 40 01 	cmp  %o1, %g1                                  
  {                                                                   
    if (it == sc)                                                     
40005874:	32 bf ff fd 	bne,a   40005868 <rtems_fdisk_queue_status+0x18>
40005878:	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' : '-';
4000587c:	10 80 00 03 	b  40005888 <rtems_fdisk_queue_status+0x38>    
40005880:	82 10 20 41 	mov  0x41, %g1                                 
40005884:	82 10 20 2d 	mov  0x2d, %g1                                 
40005888:	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;                         
4000588c:	c2 02 20 40 	ld  [ %o0 + 0x40 ], %g1                        
                                                                      
  while (it)                                                          
40005890:	80 a0 60 00 	cmp  %g1, 0                                    
40005894:	12 80 00 07 	bne  400058b0 <rtems_fdisk_queue_status+0x60>  <== ALWAYS TAKEN
40005898:	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' : '-';
4000589c:	10 80 00 0a 	b  400058c4 <rtems_fdisk_queue_status+0x74>    <== NOT EXECUTED
400058a0:	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)                                                          
400058a4:	80 a0 60 00 	cmp  %g1, 0                                    
400058a8:	02 80 00 06 	be  400058c0 <rtems_fdisk_queue_status+0x70>   
400058ac:	80 a2 40 01 	cmp  %o1, %g1                                  
  {                                                                   
    if (it == sc)                                                     
400058b0:	32 bf ff fd 	bne,a   400058a4 <rtems_fdisk_queue_status+0x54>
400058b4:	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' : '-';
400058b8:	10 80 00 03 	b  400058c4 <rtems_fdisk_queue_status+0x74>    
400058bc:	82 10 20 55 	mov  0x55, %g1                                 
400058c0:	82 10 20 2d 	mov  0x2d, %g1                                 
400058c4:	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;                         
400058c8:	c2 02 20 4c 	ld  [ %o0 + 0x4c ], %g1                        
                                                                      
  while (it)                                                          
400058cc:	80 a0 60 00 	cmp  %g1, 0                                    
400058d0:	12 80 00 07 	bne  400058ec <rtems_fdisk_queue_status+0x9c>  <== NEVER TAKEN
400058d4:	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' : '-';
400058d8:	10 80 00 0a 	b  40005900 <rtems_fdisk_queue_status+0xb0>    
400058dc:	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)                                                          
400058e0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400058e4:	02 80 00 06 	be  400058fc <rtems_fdisk_queue_status+0xac>   <== NOT EXECUTED
400058e8:	80 a2 40 01 	cmp  %o1, %g1                                  <== NOT EXECUTED
  {                                                                   
    if (it == sc)                                                     
400058ec:	32 bf ff fd 	bne,a   400058e0 <rtems_fdisk_queue_status+0x90><== NOT EXECUTED
400058f0:	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' : '-';
400058f4:	10 80 00 03 	b  40005900 <rtems_fdisk_queue_status+0xb0>    <== NOT EXECUTED
400058f8:	82 10 20 45 	mov  0x45, %g1                                 <== NOT EXECUTED
400058fc:	82 10 20 2d 	mov  0x2d, %g1                                 <== NOT EXECUTED
40005900:	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;                         
40005904:	c2 02 20 58 	ld  [ %o0 + 0x58 ], %g1                        
                                                                      
  while (it)                                                          
40005908:	80 a0 60 00 	cmp  %g1, 0                                    
4000590c:	12 80 00 07 	bne  40005928 <rtems_fdisk_queue_status+0xd8>  <== NEVER TAKEN
40005910:	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' : '-';
40005914:	10 80 00 0c 	b  40005944 <rtems_fdisk_queue_status+0xf4>    
40005918:	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)                                                          
4000591c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005920:	02 80 00 08 	be  40005940 <rtems_fdisk_queue_status+0xf0>   <== NOT EXECUTED
40005924:	80 a2 40 01 	cmp  %o1, %g1                                  <== NOT EXECUTED
  {                                                                   
    if (it == sc)                                                     
40005928:	32 bf ff fd 	bne,a   4000591c <rtems_fdisk_queue_status+0xcc><== NOT EXECUTED
4000592c:	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' : '-';
40005930:	82 10 20 46 	mov  0x46, %g1                                 <== NOT EXECUTED
  queues[4] = '\0';                                                   
40005934:	c0 2a a0 04 	clrb  [ %o2 + 4 ]                              <== NOT EXECUTED
40005938:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4000593c:	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' : '-';
40005940:	82 10 20 2d 	mov  0x2d, %g1                                 <== NOT EXECUTED
  queues[4] = '\0';                                                   
40005944:	c0 2a a0 04 	clrb  [ %o2 + 4 ]                              
40005948:	81 c3 e0 08 	retl                                           
4000594c:	c2 2a a0 03 	stb  %g1, [ %o2 + 3 ]                          
                                                                      

40006a60 <rtems_fdisk_recover_block_mappings>: /** * Recover the block mappings from the devices. */ static int rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd) {
40006a60:	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));
40006a64:	d4 06 20 1c 	ld  [ %i0 + 0x1c ], %o2                        
40006a68:	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;                                      
40006a6c:	c0 26 20 38 	clr  [ %i0 + 0x38 ]                            
40006a70:	c0 26 20 34 	clr  [ %i0 + 0x34 ]                            
  queue->count = 0;                                                   
40006a74:	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;                                      
40006a78:	c0 26 20 44 	clr  [ %i0 + 0x44 ]                            
40006a7c:	c0 26 20 40 	clr  [ %i0 + 0x40 ]                            
  queue->count = 0;                                                   
40006a80:	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;                                      
40006a84:	c0 26 20 50 	clr  [ %i0 + 0x50 ]                            
40006a88:	c0 26 20 4c 	clr  [ %i0 + 0x4c ]                            
  queue->count = 0;                                                   
40006a8c:	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;                                      
40006a90:	c0 26 20 5c 	clr  [ %i0 + 0x5c ]                            
40006a94:	c0 26 20 58 	clr  [ %i0 + 0x58 ]                            
  queue->count = 0;                                                   
40006a98:	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));
40006a9c:	92 10 20 00 	clr  %o1                                       
40006aa0:	40 00 79 39 	call  40024f84 <memset>                        
40006aa4:	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++)               
40006aa8:	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;                                              
40006aac:	c0 26 20 28 	clr  [ %i0 + 0x28 ]                            
  fd->starvation_threshold = 0;                                       
40006ab0:	c0 26 20 24 	clr  [ %i0 + 0x24 ]                            
  for (device = 0; device < fd->device_count; device++)               
40006ab4:	80 a0 e0 00 	cmp  %g3, 0                                    
40006ab8:	02 80 00 82 	be  40006cc0 <rtems_fdisk_recover_block_mappings+0x260><== NEVER TAKEN
40006abc:	ae 10 00 18 	mov  %i0, %l7                                  
40006ac0:	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);
40006ac4:	25 10 00 d5 	sethi  %hi(0x40035400), %l2                    
            ++fd->erased_blocks;                                      
          }                                                           
          else                                                        
          {                                                           
#if RTEMS_FDISK_TRACE                                                 
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
40006ac8:	29 10 00 d5 	sethi  %hi(0x40035400), %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",
40006acc:	2d 10 00 d5 	sethi  %hi(0x40035400), %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: " \      
40006ad0:	27 10 00 d6 	sethi  %hi(0x40035800), %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,                                
40006ad4:	2b 10 00 d6 	sethi  %hi(0x40035800), %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++)               
40006ad8:	a2 10 20 00 	clr  %l1                                       
40006adc:	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);
40006ae0:	a4 14 a3 60 	or  %l2, 0x360, %l2                            
            ++fd->erased_blocks;                                      
          }                                                           
          else                                                        
          {                                                           
#if RTEMS_FDISK_TRACE                                                 
            rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",      
40006ae4:	a8 15 23 d0 	or  %l4, 0x3d0, %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",
40006ae8:	ac 15 a3 f0 	or  %l6, 0x3f0, %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: " \      
40006aec:	a6 14 e0 48 	or  %l3, 0x48, %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,                                
40006af0:	aa 15 60 18 	or  %l5, 0x18, %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++)
40006af4:	82 00 80 11 	add  %g2, %l1, %g1                             
40006af8:	c8 00 60 04 	ld  [ %g1 + 4 ], %g4                           
40006afc:	a0 10 20 00 	clr  %l0                                       
40006b00:	80 a1 20 00 	cmp  %g4, 0                                    
40006b04:	02 80 00 6b 	be  40006cb0 <rtems_fdisk_recover_block_mappings+0x250><== NEVER TAKEN
40006b08:	b4 10 20 00 	clr  %i2                                       
    {                                                                 
      rtems_fdisk_segment_ctl*        sc = &fd->devices[device].segments[segment];
40006b0c:	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);
40006b10:	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];
40006b14:	b6 06 c0 10 	add  %i3, %l0, %i3                             
      const rtems_fdisk_segment_desc* sd = sc->descriptor;            
40006b18:	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);
40006b1c:	96 10 00 1a 	mov  %i2, %o3                                  
40006b20:	92 10 00 12 	mov  %l2, %o1                                  
40006b24:	7f ff fb a9 	call  400059c8 <rtems_fdisk_info>              
40006b28:	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;                                        
40006b2c:	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);
40006b30:	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;                                        
40006b34:	7f ff ee db 	call  400026a0 <.udiv>                         
40006b38:	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;                               
40006b3c:	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;                                        
40006b40:	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);            
40006b44:	91 2a 20 03 	sll  %o0, 3, %o0                               
  return ((bytes - 1) / page_size) + 1;                               
40006b48:	7f ff ee d6 	call  400026a0 <.udiv>                         
40006b4c:	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)                       
40006b50:	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;                               
40006b54:	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;
40006b58:	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);
40006b5c:	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)                       
40006b60:	80 a0 40 02 	cmp  %g1, %g2                                  
40006b64:	08 80 00 03 	bleu  40006b70 <rtems_fdisk_recover_block_mappings+0x110>
40006b68:	c2 26 e0 14 	st  %g1, [ %i3 + 0x14 ]                        
        fd->starvation_threshold = sc->pages;                         
40006b6c:	c2 25 e0 24 	st  %g1, [ %l7 + 0x24 ]                        
      sc->pages_used   = 0;                                           
      sc->pages_bad    = 0;                                           
                                                                      
      sc->failed = false;                                             
                                                                      
      if (!sc->page_descriptors)                                      
40006b70:	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;                                           
40006b74:	c0 26 e0 1c 	clr  [ %i3 + 0x1c ]                            
      sc->pages_used   = 0;                                           
40006b78:	c0 26 e0 20 	clr  [ %i3 + 0x20 ]                            
      sc->pages_bad    = 0;                                           
40006b7c:	c0 26 e0 24 	clr  [ %i3 + 0x24 ]                            
                                                                      
      sc->failed = false;                                             
40006b80:	c0 26 e0 28 	clr  [ %i3 + 0x28 ]                            
                                                                      
      if (!sc->page_descriptors)                                      
40006b84:	80 a7 60 00 	cmp  %i5, 0                                    
40006b88:	02 80 00 94 	be  40006dd8 <rtems_fdisk_recover_block_mappings+0x378><== ALWAYS TAKEN
40006b8c:	92 10 00 1c 	mov  %i4, %o1                                  
40006b90:	7f ff ee 8a 	call  400025b8 <.umul>                         <== NOT EXECUTED
40006b94:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006b98:	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,              
40006b9c:	90 10 00 17 	mov  %l7, %o0                                  
40006ba0:	92 10 00 1b 	mov  %i3, %o1                                  
40006ba4:	94 10 20 00 	clr  %o2                                       
40006ba8:	7f ff fb cc 	call  40005ad8 <rtems_fdisk_seg_read>          
40006bac:	96 10 00 1d 	mov  %i5, %o3                                  
                                  sc->pages_desc * fd->block_size);   
                                                                      
      if (ret)                                                        
40006bb0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40006bb4:	12 80 00 95 	bne  40006e08 <rtems_fdisk_recover_block_mappings+0x3a8><== NEVER TAKEN
40006bb8:	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++)                  
40006bbc:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        
40006bc0:	80 a0 a0 00 	cmp  %g2, 0                                    
40006bc4:	12 80 00 0a 	bne  40006bec <rtems_fdisk_recover_block_mappings+0x18c><== ALWAYS TAKEN
40006bc8:	b8 10 20 00 	clr  %i4                                       
      }                                                               
                                                                      
      /*                                                              
       * Place the segment on to the correct queue.                   
       */                                                             
      rtems_fdisk_queue_segment (fd, sc);                             
40006bcc:	10 80 00 2f 	b  40006c88 <rtems_fdisk_recover_block_mappings+0x228><== NOT EXECUTED
40006bd0:	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++;                                         
40006bd4:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40006bd8:	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++)                  
40006bdc:	b8 07 20 01 	inc  %i4                                       
40006be0:	80 a0 80 1c 	cmp  %g2, %i4                                  
40006be4:	08 80 00 28 	bleu  40006c84 <rtems_fdisk_recover_block_mappings+0x224>
40006be8:	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;                  
40006bec:	c2 07 40 00 	ld  [ %i5 ], %g1                               
40006bf0:	80 a0 7f ff 	cmp  %g1, -1                                   
40006bf4:	22 80 00 35 	be,a   40006cc8 <rtems_fdisk_recover_block_mappings+0x268><== ALWAYS TAKEN
40006bf8:	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;                     
40006bfc:	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))
40006c00:	80 88 60 02 	btst  2, %g1                                   <== NOT EXECUTED
40006c04:	22 bf ff f4 	be,a   40006bd4 <rtems_fdisk_recover_block_mappings+0x174><== NOT EXECUTED
40006c08:	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))
40006c0c:	80 88 60 01 	btst  1, %g1                                   <== NOT EXECUTED
40006c10:	32 80 00 43 	bne,a   40006d1c <rtems_fdisk_recover_block_mappings+0x2bc><== NOT EXECUTED
40006c14:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        <== NOT EXECUTED
          {                                                           
            if (pd->block >= fd->block_count)                         
40006c18:	da 07 60 04 	ld  [ %i5 + 4 ], %o5                           <== NOT EXECUTED
40006c1c:	c2 05 e0 1c 	ld  [ %l7 + 0x1c ], %g1                        <== NOT EXECUTED
40006c20:	80 a3 40 01 	cmp  %o5, %g1                                  <== NOT EXECUTED
40006c24:	1a 80 00 57 	bcc  40006d80 <rtems_fdisk_recover_block_mappings+0x320><== NOT EXECUTED
40006c28:	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)                   
40006c2c:	c6 05 e0 18 	ld  [ %l7 + 0x18 ], %g3                        <== NOT EXECUTED
40006c30:	9b 2b 60 03 	sll  %o5, 3, %o5                               <== NOT EXECUTED
40006c34:	c2 00 c0 0d 	ld  [ %g3 + %o5 ], %g1                         <== NOT EXECUTED
40006c38:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40006c3c:	02 80 00 5b 	be  40006da8 <rtems_fdisk_recover_block_mappings+0x348><== NOT EXECUTED
40006c40:	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: " \      
40006c44:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
40006c48:	d4 00 60 0c 	ld  [ %g1 + 0xc ], %o2                         <== NOT EXECUTED
40006c4c:	d6 01 20 04 	ld  [ %g4 + 4 ], %o3                           <== NOT EXECUTED
40006c50:	90 10 00 13 	mov  %l3, %o0                                  <== NOT EXECUTED
40006c54:	f8 23 a0 5c 	st  %i4, [ %sp + 0x5c ]                        <== NOT EXECUTED
40006c58:	98 10 00 19 	mov  %i1, %o4                                  <== NOT EXECUTED
40006c5c:	7f ff fc 57 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40006c60:	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++;                                        
40006c64:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        <== NOT EXECUTED
40006c68:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        <== NOT EXECUTED
40006c6c:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40006c70:	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++)                  
40006c74:	b8 07 20 01 	inc  %i4                                       <== NOT EXECUTED
40006c78:	80 a0 80 1c 	cmp  %g2, %i4                                  <== NOT EXECUTED
40006c7c:	18 bf ff dc 	bgu  40006bec <rtems_fdisk_recover_block_mappings+0x18c><== NOT EXECUTED
40006c80:	ba 07 60 08 	add  %i5, 8, %i5                               <== NOT EXECUTED
      }                                                               
                                                                      
      /*                                                              
       * Place the segment on to the correct queue.                   
       */                                                             
      rtems_fdisk_queue_segment (fd, sc);                             
40006c84:	90 10 00 17 	mov  %l7, %o0                                  
40006c88:	7f ff fc f4 	call  40006058 <rtems_fdisk_queue_segment>     
40006c8c:	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++)
40006c90:	c4 05 e0 2c 	ld  [ %l7 + 0x2c ], %g2                        
40006c94:	b4 06 a0 01 	inc  %i2                                       
40006c98:	82 00 80 11 	add  %g2, %l1, %g1                             
40006c9c:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
40006ca0:	80 a0 c0 1a 	cmp  %g3, %i2                                  
40006ca4:	18 bf ff 9a 	bgu  40006b0c <rtems_fdisk_recover_block_mappings+0xac>
40006ca8:	a0 04 20 30 	add  %l0, 0x30, %l0                            
40006cac:	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++)               
40006cb0:	b2 06 60 01 	inc  %i1                                       
40006cb4:	80 a0 c0 19 	cmp  %g3, %i1                                  
40006cb8:	18 bf ff 8f 	bgu  40006af4 <rtems_fdisk_recover_block_mappings+0x94><== NEVER TAKEN
40006cbc:	a2 04 60 0c 	add  %l1, 0xc, %l1                             
       */                                                             
      rtems_fdisk_queue_segment (fd, sc);                             
    }                                                                 
  }                                                                   
                                                                      
  return 0;                                                           
40006cc0:	81 c7 e0 08 	ret                                            
40006cc4:	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;                  
40006cc8:	80 a0 7f ff 	cmp  %g1, -1                                   
40006ccc:	32 bf ff cd 	bne,a   40006c00 <rtems_fdisk_recover_block_mappings+0x1a0><== NEVER TAKEN
40006cd0:	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);
40006cd4:	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,             
40006cd8:	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,                         
40006cdc:	92 10 00 18 	mov  %i0, %o1                                  
40006ce0:	7f ff ee 36 	call  400025b8 <.umul>                         
40006ce4:	90 07 00 08 	add  %i4, %o0, %o0                             
40006ce8:	92 10 00 1b 	mov  %i3, %o1                                  
40006cec:	94 10 00 08 	mov  %o0, %o2                                  
40006cf0:	96 10 00 18 	mov  %i0, %o3                                  
40006cf4:	7f ff fb 9b 	call  40005b60 <rtems_fdisk_seg_blank_check>   
40006cf8:	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)                                               
40006cfc:	80 a2 20 00 	cmp  %o0, 0                                    
40006d00:	32 80 00 0a 	bne,a   40006d28 <rtems_fdisk_recover_block_mappings+0x2c8><== NEVER TAKEN
40006d04:	da 07 60 04 	ld  [ %i5 + 4 ], %o5                           <== NOT EXECUTED
          {                                                           
            ++fd->erased_blocks;                                      
40006d08:	c2 05 e0 28 	ld  [ %l7 + 0x28 ], %g1                        
40006d0c:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        
40006d10:	82 00 60 01 	inc  %g1                                       
40006d14:	10 bf ff b2 	b  40006bdc <rtems_fdisk_recover_block_mappings+0x17c>
40006d18:	c2 25 e0 28 	st  %g1, [ %l7 + 0x28 ]                        
               */                                                     
              sc->pages_active++;                                     
            }                                                         
          }                                                           
          else                                                        
            sc->pages_bad++;                                          
40006d1c:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40006d20:	10 bf ff af 	b  40006bdc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40006d24:	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",      
40006d28:	92 10 00 14 	mov  %l4, %o1                                  <== NOT EXECUTED
40006d2c:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
40006d30:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
40006d34:	98 10 00 1c 	mov  %i4, %o4                                  <== NOT EXECUTED
40006d38:	7f ff fb fe 	call  40005d30 <rtems_fdisk_warning>           <== NOT EXECUTED
40006d3c:	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;                                                
40006d40:	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,            
40006d44:	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;                                                
40006d48:	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,            
40006d4c:	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;                                                
40006d50:	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,            
40006d54:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
40006d58:	7f ff fb c9 	call  40005c7c <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
40006d5c:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
                                                   page, pd);         
                                                                      
            if (ret)                                                  
40006d60:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40006d64:	12 80 00 17 	bne  40006dc0 <rtems_fdisk_recover_block_mappings+0x360><== NOT EXECUTED
40006d68:	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++;                                         
40006d6c:	c2 06 e0 20 	ld  [ %i3 + 0x20 ], %g1                        <== NOT EXECUTED
40006d70:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        <== NOT EXECUTED
40006d74:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40006d78:	10 bf ff 99 	b  40006bdc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40006d7c:	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,                                
40006d80:	92 10 00 15 	mov  %l5, %o1                                  <== NOT EXECUTED
40006d84:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
40006d88:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
40006d8c:	7f ff fb e9 	call  40005d30 <rtems_fdisk_warning>           <== NOT EXECUTED
40006d90:	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++;                                        
40006d94:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        <== NOT EXECUTED
40006d98:	c4 06 e0 14 	ld  [ %i3 + 0x14 ], %g2                        <== NOT EXECUTED
40006d9c:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40006da0:	10 bf ff 8f 	b  40006bdc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40006da4:	c2 26 e0 24 	st  %g1, [ %i3 + 0x24 ]                        <== NOT EXECUTED
              fd->blocks[pd->block].page    = page;                   
                                                                      
              /*                                                      
               * The page is active.                                  
               */                                                     
              sc->pages_active++;                                     
40006da8:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        <== NOT EXECUTED
            {                                                         
              /**                                                     
               * @todo                                                
               * Add start up crc checks here.                        
               */                                                     
              fd->blocks[pd->block].segment = sc;                     
40006dac:	f6 20 c0 0d 	st  %i3, [ %g3 + %o5 ]                         <== NOT EXECUTED
              fd->blocks[pd->block].page    = page;                   
40006db0:	f8 21 20 04 	st  %i4, [ %g4 + 4 ]                           <== NOT EXECUTED
                                                                      
              /*                                                      
               * The page is active.                                  
               */                                                     
              sc->pages_active++;                                     
40006db4:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40006db8:	10 bf ff 89 	b  40006bdc <rtems_fdisk_recover_block_mappings+0x17c><== NOT EXECUTED
40006dbc:	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",
40006dc0:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40006dc4:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40006dc8:	7f ff fb fc 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40006dcc:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
                                 device, segment, page);              
            }                                                         
                                                                      
            sc->pages_used++;                                         
40006dd0:	10 bf ff e8 	b  40006d70 <rtems_fdisk_recover_block_mappings+0x310><== NOT EXECUTED
40006dd4:	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);
40006dd8:	7f ff ed f8 	call  400025b8 <.umul>                         
40006ddc:	01 00 00 00 	nop                                            
40006de0:	40 00 0a 6f 	call  4000979c <malloc>                        
40006de4:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
40006de8:	d0 26 e0 10 	st  %o0, [ %i3 + 0x10 ]                        
40006dec:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
      if (!sc->page_descriptors)                                      
40006df0:	80 a2 20 00 	cmp  %o0, 0                                    
40006df4:	12 bf ff 6a 	bne  40006b9c <rtems_fdisk_recover_block_mappings+0x13c><== ALWAYS TAKEN
40006df8:	d8 07 bf fc 	ld  [ %fp + -4 ], %o4                          
        rtems_fdisk_abort ("no memory for page descriptors");         
40006dfc:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40006e00:	40 00 06 60 	call  40008780 <rtems_fdisk_abort.constprop.1> <== NOT EXECUTED
40006e04:	90 12 23 40 	or  %o0, 0x340, %o0	! 40035740 <Callbacks.6428+0x4f8><== 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: " \     
40006e08:	40 00 7d 27 	call  400262a4 <strerror>                      <== NOT EXECUTED
40006e0c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006e10:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40006e14:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
40006e18:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40006e1c:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40006e20:	98 10 00 18 	mov  %i0, %o4                                  <== NOT EXECUTED
40006e24:	7f ff fb e5 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40006e28:	90 12 23 88 	or  %o0, 0x388, %o0                            <== NOT EXECUTED
                           "read page desc failed: %s (%d)",          
                           device, segment, strerror (ret), ret);     
        return ret;                                                   
40006e2c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006e30:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40006348 <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) {
40006348:	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++)                        
4000634c:	c6 06 60 14 	ld  [ %i1 + 0x14 ], %g3                        
40006350:	c0 27 bf f8 	clr  [ %fp + -8 ]                              
40006354:	80 a0 e0 00 	cmp  %g3, 0                                    
40006358:	02 80 00 7f 	be  40006554 <rtems_fdisk_recycle_segment+0x20c><== NEVER TAKEN
4000635c:	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);        
40006360:	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++)                        
40006364:	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);        
40006368:	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];       
4000636c:	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,             
40006370:	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)                                
40006374:	80 a6 a0 00 	cmp  %i2, 0                                    
40006378:	02 80 00 8d 	be  400065ac <rtems_fdisk_recycle_segment+0x264>
4000637c:	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;                     
40006380:	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) &&
40006384:	80 88 a0 01 	btst  1, %g2                                   
40006388:	32 80 00 6b 	bne,a   40006534 <rtems_fdisk_recycle_segment+0x1ec><== NEVER TAKEN
4000638c:	c4 04 40 10 	ld  [ %l1 + %l0 ], %g2                         <== NOT EXECUTED
40006390:	80 88 a0 02 	btst  2, %g2                                   
40006394:	22 80 00 68 	be,a   40006534 <rtems_fdisk_recycle_segment+0x1ec>
40006398:	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++)                      
4000639c:	de 06 a0 14 	ld  [ %i2 + 0x14 ], %o7                        
400063a0:	80 a3 e0 00 	cmp  %o7, 0                                    
400063a4:	02 80 00 8d 	be  400065d8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
400063a8:	ee 06 a0 10 	ld  [ %i2 + 0x10 ], %l7                        
400063ac:	84 10 00 17 	mov  %l7, %g2                                  
400063b0:	10 80 00 05 	b  400063c4 <rtems_fdisk_recycle_segment+0x7c> 
400063b4:	ba 10 20 00 	clr  %i5                                       
400063b8:	80 a7 40 0f 	cmp  %i5, %o7                                  
400063bc:	02 80 00 87 	be  400065d8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
400063c0:	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;                  
400063c4:	c8 00 80 00 	ld  [ %g2 ], %g4                               
400063c8:	80 a1 3f ff 	cmp  %g4, -1                                   
400063cc:	32 bf ff fb 	bne,a   400063b8 <rtems_fdisk_recycle_segment+0x70>
400063d0:	ba 07 60 01 	inc  %i5                                       
400063d4:	c8 00 a0 04 	ld  [ %g2 + 4 ], %g4                           
400063d8:	80 a1 3f ff 	cmp  %g4, -1                                   
400063dc:	32 bf ff f7 	bne,a   400063b8 <rtems_fdisk_recycle_segment+0x70><== NEVER TAKEN
400063e0:	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];                          
400063e4:	83 2f 60 03 	sll  %i5, 3, %g1                               
400063e8:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
      active++;                                                       
400063ec:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
                                                                      
      if (dpage >= dsc->pages)                                        
400063f0:	80 a7 40 0f 	cmp  %i5, %o7                                  
      uint32_t               dpage;                                   
                                                                      
      dpage = rtems_fdisk_seg_next_available_page (dsc);              
      dpd   = &dsc->page_descriptors[dpage];                          
                                                                      
      active++;                                                       
400063f4:	82 00 60 01 	inc  %g1                                       
400063f8:	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];                          
400063fc:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
                                                                      
      active++;                                                       
                                                                      
      if (dpage >= dsc->pages)                                        
40006400:	1a 80 00 76 	bcc  400065d8 <rtems_fdisk_recycle_segment+0x290><== NEVER TAKEN
40006404:	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",
40006408:	da 06 a0 08 	ld  [ %i2 + 8 ], %o5                           
4000640c:	c4 06 a0 0c 	ld  [ %i2 + 0xc ], %g2                         
40006410:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
40006414:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         
40006418:	98 10 00 1c 	mov  %i4, %o4                                  
4000641c:	c4 23 a0 5c 	st  %g2, [ %sp + 0x5c ]                        
40006420:	13 10 00 d5 	sethi  %hi(0x40035400), %o1                    
40006424:	fa 23 a0 60 	st  %i5, [ %sp + 0x60 ]                        
40006428:	92 12 61 08 	or  %o1, 0x108, %o1                            
4000642c:	7f ff fd 67 	call  400059c8 <rtems_fdisk_info>              
40006430:	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,                       
40006434:	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",
40006438:	da 06 a0 08 	ld  [ %i2 + 8 ], %o5                           
4000643c:	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,                       
40006440:	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",
40006444:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
40006448:	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,                       
4000644c:	a8 07 00 02 	add  %i4, %g2, %l4                             
40006450:	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",
40006454:	de 23 a0 5c 	st  %o7, [ %sp + 0x5c ]                        
40006458:	98 10 00 14 	mov  %l4, %o4                                  
4000645c:	13 10 00 d5 	sethi  %hi(0x40035400), %o1                    
40006460:	ea 23 a0 60 	st  %l5, [ %sp + 0x60 ]                        
40006464:	92 12 61 30 	or  %o1, 0x130, %o1                            
40006468:	7f ff fd 7a 	call  40005a50 <rtems_fdisk_printf>            
4000646c:	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);
40006470:	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,                                
40006474:	90 10 00 14 	mov  %l4, %o0                                  
40006478:	92 10 00 0c 	mov  %o4, %o1                                  
4000647c:	7f ff f0 4f 	call  400025b8 <.umul>                         
40006480:	d8 27 bf ec 	st  %o4, [ %fp + -20 ]                         
40006484:	d6 06 20 68 	ld  [ %i0 + 0x68 ], %o3                        
40006488:	d8 07 bf ec 	ld  [ %fp + -20 ], %o4                         
4000648c:	94 10 00 08 	mov  %o0, %o2                                  
40006490:	92 10 00 19 	mov  %i1, %o1                                  
40006494:	7f ff fd 91 	call  40005ad8 <rtems_fdisk_seg_read>          
40006498:	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)                                                            
4000649c:	84 92 20 00 	orcc  %o0, 0, %g2                              
400064a0:	22 80 00 6a 	be,a   40006648 <rtems_fdisk_recycle_segment+0x300><== ALWAYS TAKEN
400064a4:	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=>" \              
400064a8:	e2 06 a0 08 	ld  [ %i2 + 8 ], %l1                           <== NOT EXECUTED
400064ac:	e0 06 a0 0c 	ld  [ %i2 + 0xc ], %l0                         <== NOT EXECUTED
400064b0:	e4 06 60 0c 	ld  [ %i1 + 0xc ], %l2                         <== NOT EXECUTED
400064b4:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           <== NOT EXECUTED
400064b8:	90 10 00 02 	mov  %g2, %o0                                  <== NOT EXECUTED
400064bc:	40 00 7f 7a 	call  400262a4 <strerror>                      <== NOT EXECUTED
400064c0:	c4 27 bf f0 	st  %g2, [ %fp + -16 ]                         <== NOT EXECUTED
400064c4:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         <== NOT EXECUTED
400064c8:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        <== NOT EXECUTED
400064cc:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
400064d0:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
400064d4:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
400064d8:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
400064dc:	9a 10 00 10 	mov  %l0, %o5                                  <== NOT EXECUTED
400064e0:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        <== NOT EXECUTED
400064e4:	c4 23 a0 64 	st  %g2, [ %sp + 0x64 ]                        <== NOT EXECUTED
400064e8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
400064ec:	90 12 21 60 	or  %o0, 0x160, %o0                            <== NOT EXECUTED
                                             dsc,                     
                                             dpage, dpd);             
                                                                      
      if (ret)                                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d-%03d=>"   \            
400064f0:	7f ff fe 32 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
400064f4:	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);                          
400064f8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400064fc:	7f ff fe d7 	call  40006058 <rtems_fdisk_queue_segment>     <== NOT EXECUTED
40006500:	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;                                           
40006504:	c6 06 20 40 	ld  [ %i0 + 0x40 ], %g3                        <== NOT EXECUTED
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
40006508:	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;                                           
4000650c:	c6 26 40 00 	st  %g3, [ %i1 ]                               <== NOT EXECUTED
    queue->head = sc;                                                 
40006510:	f2 26 20 40 	st  %i1, [ %i0 + 0x40 ]                        <== NOT EXECUTED
                                                                      
    if (queue->tail == 0)                                             
40006514:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40006518:	02 80 00 98 	be  40006778 <rtems_fdisk_recycle_segment+0x430><== NOT EXECUTED
4000651c:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         <== NOT EXECUTED
      queue->tail = sc;                                               
    queue->count++;                                                   
40006520:	c2 06 20 48 	ld  [ %i0 + 0x48 ], %g1                        <== NOT EXECUTED
40006524:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40006528:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        <== NOT EXECUTED
  }                                                                   
                                                                      
  ret = rtems_fdisk_erase_segment (fd, ssc);                          
                                                                      
  return ret;                                                         
}                                                                     
4000652c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006530:	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;                  
40006534:	80 a0 bf ff 	cmp  %g2, -1                                   
40006538:	22 80 00 16 	be,a   40006590 <rtems_fdisk_recycle_segment+0x248><== NEVER TAKEN
4000653c:	c2 05 a0 04 	ld  [ %l6 + 4 ], %g1                           <== NOT EXECUTED
    {                                                                 
      --fd->erased_blocks;                                            
    }                                                                 
    else                                                              
    {                                                                 
      used++;                                                         
40006540:	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++)                        
40006544:	b8 07 20 01 	inc  %i4                                       
40006548:	80 a0 c0 1c 	cmp  %g3, %i4                                  
4000654c:	38 bf ff 89 	bgu,a   40006370 <rtems_fdisk_recycle_segment+0x28>
40006550:	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",      
40006554:	d4 06 60 08 	ld  [ %i1 + 8 ], %o2                           
40006558:	d6 06 60 0c 	ld  [ %i1 + 0xc ], %o3                         
4000655c:	da 07 bf f8 	ld  [ %fp + -8 ], %o5                          
40006560:	e4 23 a0 5c 	st  %l2, [ %sp + 0x5c ]                        
40006564:	90 10 00 18 	mov  %i0, %o0                                  
40006568:	13 10 00 d5 	sethi  %hi(0x40035400), %o1                    
4000656c:	98 10 00 1b 	mov  %i3, %o4                                  
40006570:	7f ff fd 38 	call  40005a50 <rtems_fdisk_printf>            
40006574:	92 12 61 f0 	or  %o1, 0x1f0, %o1                            
                      ssc->device, ssc->segment,                      
                      pages, active, used);                           
#endif                                                                
  if (ssc->pages_active != 0)                                         
40006578:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
4000657c:	80 a2 60 00 	cmp  %o1, 0                                    
40006580:	12 80 00 69 	bne  40006724 <rtems_fdisk_recycle_segment+0x3dc><== NEVER TAKEN
40006584:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    
  {                                                                   
    rtems_fdisk_error ("compacting: ssc pages not 0: %d",             
                       ssc->pages_active);                            
  }                                                                   
                                                                      
  ret = rtems_fdisk_erase_segment (fd, ssc);                          
40006588:	7f ff fe 2b 	call  40005e34 <rtems_fdisk_erase_segment>     
4000658c:	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;                  
40006590:	80 a0 7f ff 	cmp  %g1, -1                                   <== NOT EXECUTED
40006594:	32 bf ff ec 	bne,a   40006544 <rtems_fdisk_recycle_segment+0x1fc><== NOT EXECUTED
40006598:	a4 04 a0 01 	inc  %l2                                       <== NOT EXECUTED
                                                                      
      (*pages)--;                                                     
    }                                                                 
    else if (rtems_fdisk_page_desc_erased (spd))                      
    {                                                                 
      --fd->erased_blocks;                                            
4000659c:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
400065a0:	82 00 7f ff 	add  %g1, -1, %g1                              <== NOT EXECUTED
400065a4:	10 bf ff e8 	b  40006544 <rtems_fdisk_recycle_segment+0x1fc><== NOT EXECUTED
400065a8:	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)                                
400065ac:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
400065b0:	80 a0 a0 00 	cmp  %g2, 0                                    
400065b4:	22 bf ff 74 	be,a   40006384 <rtems_fdisk_recycle_segment+0x3c><== ALWAYS TAKEN
400065b8:	c4 15 a0 02 	lduh  [ %l6 + 2 ], %g2                         
    {                                                                 
      rtems_fdisk_error ("recycle: no available dst segment");        
      return EIO;                                                     
400065bc:	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");        
400065c0:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
400065c4:	c4 27 bf f0 	st  %g2, [ %fp + -16 ]                         <== NOT EXECUTED
400065c8:	7f ff fd fc 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
400065cc:	90 12 20 b0 	or  %o0, 0xb0, %o0                             <== NOT EXECUTED
      return EIO;                                                     
400065d0:	10 bf ff d7 	b  4000652c <rtems_fdisk_recycle_segment+0x1e4><== NOT EXECUTED
400065d4:	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,             
400065d8:	c4 06 a0 1c 	ld  [ %i2 + 0x1c ], %g2                        <== NOT EXECUTED
400065dc:	c2 06 a0 20 	ld  [ %i2 + 0x20 ], %g1                        <== NOT EXECUTED
400065e0:	d6 06 a0 24 	ld  [ %i2 + 0x24 ], %o3                        <== NOT EXECUTED
                                                                      
      active++;                                                       
                                                                      
      if (dpage >= dsc->pages)                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d: " \                   
400065e4:	d2 06 a0 08 	ld  [ %i2 + 8 ], %o1                           <== NOT EXECUTED
400065e8:	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,             
400065ec:	96 02 c0 02 	add  %o3, %g2, %o3                             <== NOT EXECUTED
                                                                      
      active++;                                                       
                                                                      
      if (dpage >= dsc->pages)                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d: " \                   
400065f0:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
      rtems_fdisk_segment_queue_push_tail (&fd->available, sc);       
  }                                                                   
}                                                                     
                                                                      
static int                                                            
rtems_fdisk_recycle_segment (rtems_flashdisk*         fd,             
400065f4:	96 02 c0 01 	add  %o3, %g1, %o3                             <== NOT EXECUTED
                                                                      
      active++;                                                       
                                                                      
      if (dpage >= dsc->pages)                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d: " \                   
400065f8:	96 23 c0 0b 	sub  %o7, %o3, %o3                             <== NOT EXECUTED
400065fc:	7f ff fd ef 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40006600:	90 12 20 d8 	or  %o0, 0xd8, %o0                             <== NOT EXECUTED
                           "no page desc available: %d",              
                           dsc->device, dsc->segment,                 
                           rtems_fdisk_seg_pages_available (dsc));    
        dsc->failed = true;                                           
40006604:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
        rtems_fdisk_queue_segment (fd, dsc);                          
40006608:	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;                                           
4000660c:	c2 26 a0 28 	st  %g1, [ %i2 + 0x28 ]                        <== NOT EXECUTED
        rtems_fdisk_queue_segment (fd, dsc);                          
40006610:	7f ff fe 92 	call  40006058 <rtems_fdisk_queue_segment>     <== NOT EXECUTED
40006614:	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;                                           
40006618:	c4 06 20 40 	ld  [ %i0 + 0x40 ], %g2                        <== NOT EXECUTED
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
4000661c:	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;                                           
40006620:	c4 26 40 00 	st  %g2, [ %i1 ]                               <== NOT EXECUTED
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
40006624:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40006628:	02 80 00 56 	be  40006780 <rtems_fdisk_recycle_segment+0x438><== NOT EXECUTED
4000662c:	f2 26 20 40 	st  %i1, [ %i0 + 0x40 ]                        <== NOT EXECUTED
      queue->tail = sc;                                               
    queue->count++;                                                   
40006630:	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;                                                   
40006634:	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++;                                                   
40006638:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
4000663c:	c2 26 20 48 	st  %g1, [ %i0 + 0x48 ]                        <== NOT EXECUTED
  }                                                                   
                                                                      
  ret = rtems_fdisk_erase_segment (fd, ssc);                          
                                                                      
  return ret;                                                         
}                                                                     
40006640:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40006644:	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,            
40006648:	90 10 00 18 	mov  %i0, %o0                                  
4000664c:	92 10 00 1a 	mov  %i2, %o1                                  
40006650:	7f ff fd 9c 	call  40005cc0 <rtems_fdisk_seg_write_page>    
40006654:	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)                                                        
40006658:	84 92 20 00 	orcc  %o0, 0, %g2                              
4000665c:	12 bf ff 93 	bne  400064a8 <rtems_fdisk_recycle_segment+0x160><== NEVER TAKEN
40006660:	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;                                                    
40006664:	c4 04 40 10 	ld  [ %l1 + %l0 ], %g2                         
                                                                      
      ret = rtems_fdisk_seg_write_page_desc (fd,                      
40006668:	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;                                                    
4000666c:	c4 25 c0 01 	st  %g2, [ %l7 + %g1 ]                         
40006670:	c4 05 a0 04 	ld  [ %l6 + 4 ], %g2                           
                                                                      
      ret = rtems_fdisk_seg_write_page_desc (fd,                      
40006674:	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;                                                    
40006678:	c4 24 e0 04 	st  %g2, [ %l3 + 4 ]                           
                                                                      
      ret = rtems_fdisk_seg_write_page_desc (fd,                      
4000667c:	94 10 00 1d 	mov  %i5, %o2                                  
40006680:	7f ff fd 7f 	call  40005c7c <rtems_fdisk_seg_write_page_desc>
40006684:	96 10 00 13 	mov  %l3, %o3                                  
                                             dsc,                     
                                             dpage, dpd);             
                                                                      
      if (ret)                                                        
40006688:	84 92 20 00 	orcc  %o0, 0, %g2                              
4000668c:	32 80 00 2a 	bne,a   40006734 <rtems_fdisk_recycle_segment+0x3ec><== NEVER TAKEN
40006690:	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++;                                            
40006694:	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++;                                              
40006698:	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++;                                            
4000669c:	84 00 a0 01 	inc  %g2                                       
       */                                                             
                                                                      
      ssc->pages_active--;                                            
      ssc->pages_used++;                                              
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400066a0:	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++;                                            
400066a4:	c4 26 a0 1c 	st  %g2, [ %i2 + 0x1c ]                        
       */                                                             
                                                                      
      ssc->pages_active--;                                            
      ssc->pages_used++;                                              
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400066a8:	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--;                                            
400066ac:	c8 06 60 1c 	ld  [ %i1 + 0x1c ], %g4                        
      ssc->pages_used++;                                              
400066b0:	86 00 e0 01 	inc  %g3                                       
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400066b4:	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++;                                              
400066b8:	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--;                                            
400066bc:	88 01 3f ff 	add  %g4, -1, %g4                              
      ssc->pages_used++;                                              
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400066c0:	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--;                                            
400066c4:	c8 26 60 1c 	st  %g4, [ %i1 + 0x1c ]                        
      ssc->pages_used++;                                              
                                                                      
      fd->blocks[spd->block].segment = dsc;                           
400066c8:	f4 20 80 01 	st  %i2, [ %g2 + %g1 ]                         
      fd->blocks[spd->block].page    = dpage;                         
400066cc:	fa 20 e0 04 	st  %i5, [ %g3 + 4 ]                           
                                                                      
      /*                                                              
       * Place the segment on to the correct queue.                   
       */                                                             
      rtems_fdisk_queue_segment (fd, dsc);                            
400066d0:	90 10 00 18 	mov  %i0, %o0                                  
400066d4:	7f ff fe 61 	call  40006058 <rtems_fdisk_queue_segment>     
400066d8:	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);
400066dc:	c8 06 a0 20 	ld  [ %i2 + 0x20 ], %g4                        
400066e0:	c2 06 a0 1c 	ld  [ %i2 + 0x1c ], %g1                        
400066e4:	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)                                             
400066e8:	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);
400066ec:	82 01 00 01 	add  %g4, %g1, %g1                             
400066f0:	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)                                             
400066f4:	80 a0 80 01 	cmp  %g2, %g1                                  
400066f8:	02 80 00 07 	be  40006714 <rtems_fdisk_recycle_segment+0x3cc>
400066fc:	01 00 00 00 	nop                                            
        dsc = rtems_fdisk_seg_most_available (&fd->available);        
                                                                      
      (*pages)--;                                                     
40006700:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
40006704:	82 00 7f ff 	add  %g1, -1, %g1                              
40006708:	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))
    {                                                                 
4000670c:	10 bf ff 8e 	b  40006544 <rtems_fdisk_recycle_segment+0x1fc>
40006710:	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);        
40006714:	7f ff fc 8f 	call  40005950 <rtems_fdisk_seg_most_available>
40006718:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
4000671c:	10 bf ff f9 	b  40006700 <rtems_fdisk_recycle_segment+0x3b8>
40006720:	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",             
40006724:	7f ff fd a5 	call  40005db8 <rtems_fdisk_error>             <== NOT EXECUTED
40006728:	90 12 22 18 	or  %o0, 0x218, %o0                            <== NOT EXECUTED
                       ssc->pages_active);                            
  }                                                                   
                                                                      
  ret = rtems_fdisk_erase_segment (fd, ssc);                          
4000672c:	7f ff fd c2 	call  40005e34 <rtems_fdisk_erase_segment>     <== NOT EXECUTED
40006730:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                             dsc,                     
                                             dpage, dpd);             
                                                                      
      if (ret)                                                        
      {                                                               
        rtems_fdisk_error ("recycle: %02d-%03d-%03d=>"   \            
40006734:	e0 06 a0 0c 	ld  [ %i2 + 0xc ], %l0                         <== NOT EXECUTED
40006738:	e4 06 60 0c 	ld  [ %i1 + 0xc ], %l2                         <== NOT EXECUTED
4000673c:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           <== NOT EXECUTED
40006740:	40 00 7e d9 	call  400262a4 <strerror>                      <== NOT EXECUTED
40006744:	c4 27 bf f0 	st  %g2, [ %fp + -16 ]                         <== NOT EXECUTED
40006748:	c4 07 bf f0 	ld  [ %fp + -16 ], %g2                         <== NOT EXECUTED
4000674c:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        <== NOT EXECUTED
40006750:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
40006754:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40006758:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4000675c:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
40006760:	9a 10 00 10 	mov  %l0, %o5                                  <== NOT EXECUTED
40006764:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        <== NOT EXECUTED
40006768:	c4 23 a0 64 	st  %g2, [ %sp + 0x64 ]                        <== NOT EXECUTED
4000676c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40006770:	10 bf ff 60 	b  400064f0 <rtems_fdisk_recycle_segment+0x1a8><== NOT EXECUTED
40006774:	90 12 21 a8 	or  %o0, 0x1a8, %o0                            <== NOT EXECUTED
  {                                                                   
    sc->next = queue->head;                                           
    queue->head = sc;                                                 
                                                                      
    if (queue->tail == 0)                                             
      queue->tail = sc;                                               
40006778:	10 bf ff 6a 	b  40006520 <rtems_fdisk_recycle_segment+0x1d8><== NOT EXECUTED
4000677c:	f2 26 20 44 	st  %i1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
40006780:	10 bf ff ac 	b  40006630 <rtems_fdisk_recycle_segment+0x2e8><== NOT EXECUTED
40006784:	f2 26 20 44 	st  %i1, [ %i0 + 0x44 ]                        <== NOT EXECUTED
                                                                      

40005be4 <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) {
40005be4:	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;                                                
40005be8:	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;            
40005bec:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
40005bf0:	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;                                              
40005bf4:	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;            
40005bf8:	83 2c 20 02 	sll  %l0, 2, %g1                               
40005bfc:	82 20 c0 01 	sub  %g3, %g1, %g1                             
40005c00:	86 00 80 01 	add  %g2, %g1, %g3                             
40005c04:	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;                    
40005c08:	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;            
40005c0c:	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;                    
40005c10:	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;            
40005c14:	87 2f 60 06 	sll  %i5, 6, %g3                               
40005c18:	84 20 c0 02 	sub  %g3, %g2, %g2                             
40005c1c:	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",      
40005c20:	94 10 00 10 	mov  %l0, %o2                                  
40005c24:	96 10 00 1d 	mov  %i5, %o3                                  
40005c28:	98 10 00 1a 	mov  %i2, %o4                                  
40005c2c:	9a 10 00 1c 	mov  %i4, %o5                                  
40005c30:	90 10 00 18 	mov  %i0, %o0                                  
40005c34:	13 10 00 d4 	sethi  %hi(0x40035000), %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;            
40005c38:	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",      
40005c3c:	7f ff ff 85 	call  40005a50 <rtems_fdisk_printf>            
40005c40:	92 12 63 d8 	or  %o1, 0x3d8, %o1                            
                      device, segment, offset, size);                 
#endif                                                                
  ret = ops->write (sd, device, segment, offset, buffer, size);       
40005c44:	c2 04 60 04 	ld  [ %l1 + 4 ], %g1                           
40005c48:	90 10 00 18 	mov  %i0, %o0                                  
40005c4c:	92 10 00 10 	mov  %l0, %o1                                  
40005c50:	94 10 00 1d 	mov  %i5, %o2                                  
40005c54:	96 10 00 1a 	mov  %i2, %o3                                  
40005c58:	98 10 00 1b 	mov  %i3, %o4                                  
40005c5c:	9f c0 40 00 	call  %g1                                      
40005c60:	9a 10 00 1c 	mov  %i4, %o5                                  
  if (ret)                                                            
40005c64:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40005c68:	02 80 00 03 	be  40005c74 <rtems_fdisk_seg_write+0x90>      <== ALWAYS TAKEN
40005c6c:	82 10 20 01 	mov  1, %g1                                    
    sc->failed = true;                                                
40005c70:	c2 26 60 28 	st  %g1, [ %i1 + 0x28 ]                        <== NOT EXECUTED
                                                                      
  return ret;                                                         
}                                                                     
40005c74:	81 c7 e0 08 	ret                                            
40005c78:	81 e8 00 00 	restore                                        
                                                                      

40005cc0 <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) {
40005cc0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))             
40005cc4:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40005cc8:	80 88 60 08 	btst  8, %g1                                   
40005ccc:	22 80 00 0f 	be,a   40005d08 <rtems_fdisk_seg_write_page+0x48><== NEVER TAKEN
40005cd0:	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);
40005cd4:	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,                         
40005cd8:	90 10 00 1a 	mov  %i2, %o0                                  
40005cdc:	7f ff f2 37 	call  400025b8 <.umul>                         
40005ce0:	92 10 00 1d 	mov  %i5, %o1                                  
40005ce4:	92 10 00 19 	mov  %i1, %o1                                  
40005ce8:	94 10 00 08 	mov  %o0, %o2                                  
40005cec:	96 10 00 1d 	mov  %i5, %o3                                  
40005cf0:	7f ff ff 9c 	call  40005b60 <rtems_fdisk_seg_blank_check>   
40005cf4:	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)                                                          
40005cf8:	80 a2 20 00 	cmp  %o0, 0                                    
40005cfc:	12 80 00 0b 	bne  40005d28 <rtems_fdisk_seg_write_page+0x68><== NEVER TAKEN
40005d00:	01 00 00 00 	nop                                            
      return ret;                                                     
  }                                                                   
  --fd->erased_blocks;                                                
40005d04:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
  return rtems_fdisk_seg_write (fd, sc,                               
                                page * fd->block_size, buffer, fd->block_size);
40005d08:	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;                                                
40005d0c:	82 00 7f ff 	add  %g1, -1, %g1                              
  return rtems_fdisk_seg_write (fd, sc,                               
40005d10:	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;                                                
40005d14:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
  return rtems_fdisk_seg_write (fd, sc,                               
40005d18:	7f ff f2 28 	call  400025b8 <.umul>                         
40005d1c:	92 10 00 1c 	mov  %i4, %o1                                  
40005d20:	7f ff ff b1 	call  40005be4 <rtems_fdisk_seg_write>         
40005d24:	95 e8 00 08 	restore  %g0, %o0, %o2                         
                                page * fd->block_size, buffer, fd->block_size);
}                                                                     
40005d28:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005d2c:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

40005c7c <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) {
40005c7c:	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))             
40005c80:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
40005c84:	80 88 60 08 	btst  8, %g1                                   
40005c88:	02 80 00 0a 	be  40005cb0 <rtems_fdisk_seg_write_page_desc+0x34><== NEVER TAKEN
40005c8c:	b5 2e a0 03 	sll  %i2, 3, %i2                               
  {                                                                   
    int ret = rtems_fdisk_seg_blank_check (fd, sc,                    
40005c90:	90 10 00 18 	mov  %i0, %o0                                  
40005c94:	92 10 00 19 	mov  %i1, %o1                                  
40005c98:	94 10 00 1a 	mov  %i2, %o2                                  
40005c9c:	7f ff ff b1 	call  40005b60 <rtems_fdisk_seg_blank_check>   
40005ca0:	96 10 20 08 	mov  8, %o3                                    
                                           offset,                    
                                           sizeof (rtems_fdisk_page_desc));
    if (ret)                                                          
40005ca4:	80 a2 20 00 	cmp  %o0, 0                                    
40005ca8:	12 80 00 04 	bne  40005cb8 <rtems_fdisk_seg_write_page_desc+0x3c><== NEVER TAKEN
40005cac:	01 00 00 00 	nop                                            
      return ret;                                                     
  }                                                                   
  return rtems_fdisk_seg_write (fd, sc, offset,                       
40005cb0:	7f ff ff cd 	call  40005be4 <rtems_fdisk_seg_write>         
40005cb4:	99 e8 20 08 	restore  %g0, 8, %o4                           
                                page_desc, sizeof (rtems_fdisk_page_desc));
}                                                                     
40005cb8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005cbc:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

40005fb0 <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)
40005fb0:	80 a2 60 00 	cmp  %o1, 0                                    
40005fb4:	02 80 00 12 	be  40005ffc <rtems_fdisk_segment_queue_insert_before+0x4c><== NEVER TAKEN
40005fb8:	80 a2 a0 00 	cmp  %o2, 0                                    
  {                                                                   
    rtems_fdisk_segment_ctl** prev = &queue->head;                    
    rtems_fdisk_segment_ctl*  it = queue->head;                       
40005fbc:	c4 02 00 00 	ld  [ %o0 ], %g2                               
                                                                      
    while (it)                                                        
40005fc0:	80 a0 a0 00 	cmp  %g2, 0                                    
40005fc4:	02 80 00 0d 	be  40005ff8 <rtems_fdisk_segment_queue_insert_before+0x48><== NEVER TAKEN
40005fc8:	80 a2 40 02 	cmp  %o1, %g2                                  
    {                                                                 
      if (item == it)                                                 
40005fcc:	32 80 00 08 	bne,a   40005fec <rtems_fdisk_segment_queue_insert_before+0x3c>
40005fd0:	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;                    
40005fd4:	10 80 00 18 	b  40006034 <rtems_fdisk_segment_queue_insert_before+0x84>
40005fd8:	84 10 00 08 	mov  %o0, %g2                                  
    rtems_fdisk_segment_ctl*  it = queue->head;                       
                                                                      
    while (it)                                                        
    {                                                                 
      if (item == it)                                                 
40005fdc:	22 80 00 17 	be,a   40006038 <rtems_fdisk_segment_queue_insert_before+0x88><== ALWAYS TAKEN
40005fe0:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
40005fe4:	84 10 00 01 	mov  %g1, %g2                                  <== NOT EXECUTED
        queue->count++;                                               
        return;                                                       
      }                                                               
                                                                      
      prev = &it->next;                                               
      it = it->next;                                                  
40005fe8:	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)                                                        
40005fec:	80 a0 60 00 	cmp  %g1, 0                                    
40005ff0:	12 bf ff fb 	bne  40005fdc <rtems_fdisk_segment_queue_insert_before+0x2c><== ALWAYS TAKEN
40005ff4:	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)                                                             
40005ff8:	80 a2 a0 00 	cmp  %o2, 0                                    <== NOT EXECUTED
40005ffc:	02 80 00 0c 	be  4000602c <rtems_fdisk_segment_queue_insert_before+0x7c><== NOT EXECUTED
40006000:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    sc->next = 0;                                                     
                                                                      
    if (queue->head)                                                  
40006004:	c2 02 00 00 	ld  [ %o0 ], %g1                               <== NOT EXECUTED
40006008:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000600c:	02 80 00 10 	be  4000604c <rtems_fdisk_segment_queue_insert_before+0x9c><== NOT EXECUTED
40006010:	c0 22 80 00 	clr  [ %o2 ]                                   <== NOT EXECUTED
    {                                                                 
      queue->tail->next = sc;                                         
40006014:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           <== NOT EXECUTED
40006018:	d4 20 40 00 	st  %o2, [ %g1 ]                               <== NOT EXECUTED
      queue->tail       = sc;                                         
4000601c:	d4 22 20 04 	st  %o2, [ %o0 + 4 ]                           <== NOT EXECUTED
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
    }                                                                 
                                                                      
    queue->count++;                                                   
40006020:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           <== NOT EXECUTED
40006024:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
40006028:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           <== NOT EXECUTED
4000602c:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40006030:	01 00 00 00 	nop                                            <== NOT EXECUTED
    {                                                                 
      if (item == it)                                                 
      {                                                               
        sc->next = item;                                              
        *prev = sc;                                                   
        queue->count++;                                               
40006034:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
                                                                      
    while (it)                                                        
    {                                                                 
      if (item == it)                                                 
      {                                                               
        sc->next = item;                                              
40006038:	d2 22 80 00 	st  %o1, [ %o2 ]                               
        *prev = sc;                                                   
4000603c:	d4 20 80 00 	st  %o2, [ %g2 ]                               
        queue->count++;                                               
40006040:	82 00 60 01 	inc  %g1                                       
        return;                                                       
40006044:	81 c3 e0 08 	retl                                           
40006048:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
      queue->tail->next = sc;                                         
      queue->tail       = sc;                                         
    }                                                                 
    else                                                              
    {                                                                 
      queue->head = queue->tail = sc;                                 
4000604c:	d4 22 20 04 	st  %o2, [ %o0 + 4 ]                           <== NOT EXECUTED
40006050:	10 bf ff f4 	b  40006020 <rtems_fdisk_segment_queue_insert_before+0x70><== NOT EXECUTED
40006054:	d4 22 00 00 	st  %o2, [ %o0 ]                               <== NOT EXECUTED
                                                                      

400057cc <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;
400057cc:	c4 02 00 00 	ld  [ %o0 ], %g2                               
                                                                      
  /*                                                                  
   * Do not change sc->next as sc could be on another queue.          
   */                                                                 
                                                                      
  while (it)                                                          
400057d0:	80 a0 a0 00 	cmp  %g2, 0                                    
400057d4:	02 80 00 0d 	be  40005808 <rtems_fdisk_segment_queue_remove+0x3c>
400057d8:	80 a0 80 09 	cmp  %g2, %o1                                  
  {                                                                   
    if (sc == it)                                                     
400057dc:	32 80 00 08 	bne,a   400057fc <rtems_fdisk_segment_queue_remove+0x30>
400057e0:	c2 00 80 00 	ld  [ %g2 ], %g1                               
    {                                                                 
      if (prev == 0)                                                  
      {                                                               
        queue->head = sc->next;                                       
400057e4:	10 80 00 16 	b  4000583c <rtems_fdisk_segment_queue_remove+0x70>
400057e8:	c2 02 40 00 	ld  [ %o1 ], %g1                               
   * Do not change sc->next as sc could be on another queue.          
   */                                                                 
                                                                      
  while (it)                                                          
  {                                                                   
    if (sc == it)                                                     
400057ec:	22 80 00 09 	be,a   40005810 <rtems_fdisk_segment_queue_remove+0x44>
400057f0:	c6 02 40 00 	ld  [ %o1 ], %g3                               
400057f4:	84 10 00 01 	mov  %g1, %g2                                  
      queue->count--;                                                 
      break;                                                          
    }                                                                 
                                                                      
    prev = it;                                                        
    it = it->next;                                                    
400057f8:	c2 00 80 00 	ld  [ %g2 ], %g1                               
                                                                      
  /*                                                                  
   * Do not change sc->next as sc could be on another queue.          
   */                                                                 
                                                                      
  while (it)                                                          
400057fc:	80 a0 60 00 	cmp  %g1, 0                                    
40005800:	12 bf ff fb 	bne  400057ec <rtems_fdisk_segment_queue_remove+0x20>
40005804:	80 a2 40 01 	cmp  %o1, %g1                                  
40005808:	81 c3 e0 08 	retl                                           
4000580c:	01 00 00 00 	nop                                            
          queue->tail = 0;                                            
      }                                                               
      else                                                            
      {                                                               
        prev->next = sc->next;                                        
        if (queue->tail == sc)                                        
40005810:	c2 02 20 04 	ld  [ %o0 + 4 ], %g1                           
40005814:	80 a0 40 09 	cmp  %g1, %o1                                  
40005818:	02 80 00 07 	be  40005834 <rtems_fdisk_segment_queue_remove+0x68><== ALWAYS TAKEN
4000581c:	c6 20 80 00 	st  %g3, [ %g2 ]                               
          queue->tail = prev;                                         
      }                                                               
      sc->next = 0;                                                   
      queue->count--;                                                 
40005820:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
      {                                                               
        prev->next = sc->next;                                        
        if (queue->tail == sc)                                        
          queue->tail = prev;                                         
      }                                                               
      sc->next = 0;                                                   
40005824:	c0 22 40 00 	clr  [ %o1 ]                                   
      queue->count--;                                                 
40005828:	82 00 7f ff 	add  %g1, -1, %g1                              
      break;                                                          
4000582c:	81 c3 e0 08 	retl                                           
40005830:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
      }                                                               
      else                                                            
      {                                                               
        prev->next = sc->next;                                        
        if (queue->tail == sc)                                        
          queue->tail = prev;                                         
40005834:	10 bf ff fb 	b  40005820 <rtems_fdisk_segment_queue_remove+0x54>
40005838:	c4 22 20 04 	st  %g2, [ %o0 + 4 ]                           
    if (sc == it)                                                     
    {                                                                 
      if (prev == 0)                                                  
      {                                                               
        queue->head = sc->next;                                       
        if (queue->head == 0)                                         
4000583c:	80 a0 60 00 	cmp  %g1, 0                                    
40005840:	12 bf ff f8 	bne  40005820 <rtems_fdisk_segment_queue_remove+0x54>
40005844:	c2 22 00 00 	st  %g1, [ %o0 ]                               
          queue->tail = 0;                                            
40005848:	10 bf ff f6 	b  40005820 <rtems_fdisk_segment_queue_remove+0x54>
4000584c:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
                                                                      

40005d30 <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, ...) {
40005d30:	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);                                          
40005d34:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
40005d38:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
40005d3c:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
40005d40:	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)                                            
40005d44:	c2 06 20 6c 	ld  [ %i0 + 0x6c ], %g1                        <== NOT EXECUTED
40005d48:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40005d4c:	02 80 00 19 	be  40005db0 <rtems_fdisk_warning+0x80>        <== NOT EXECUTED
40005d50:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:warning:");                               
40005d54:	3b 10 00 e9 	sethi  %hi(0x4003a400), %i5                    <== NOT EXECUTED
40005d58:	c2 07 61 78 	ld  [ %i5 + 0x178 ], %g1	! 4003a578 <_impure_ptr><== NOT EXECUTED
40005d5c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40005d60:	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);                                          
40005d64:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            <== NOT EXECUTED
    fprintf (stdout, "fdisk:warning:");                               
40005d68:	94 10 20 0e 	mov  0xe, %o2                                  <== NOT EXECUTED
{                                                                     
  int ret = 0;                                                        
  if (fd->info_level >= 1)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
40005d6c:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
    fprintf (stdout, "fdisk:warning:");                               
40005d70:	11 10 00 d5 	sethi  %hi(0x40035400), %o0                    <== NOT EXECUTED
40005d74:	40 00 7b 6d 	call  40024b28 <fwrite>                        <== NOT EXECUTED
40005d78:	90 12 20 00 	mov  %o0, %o0	! 40035400 <Callbacks.6428+0x1b8><== NOT EXECUTED
    ret =  vfprintf (stdout, format, args);                           
40005d7c:	c2 07 61 78 	ld  [ %i5 + 0x178 ], %g1                       <== NOT EXECUTED
40005d80:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
40005d84:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
40005d88:	40 00 9c cd 	call  4002d0bc <vfprintf>                      <== NOT EXECUTED
40005d8c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
40005d90:	c2 07 61 78 	ld  [ %i5 + 0x178 ], %g1                       <== NOT EXECUTED
  if (fd->info_level >= 1)                                            
  {                                                                   
    va_list args;                                                     
    va_start (args, format);                                          
    fprintf (stdout, "fdisk:warning:");                               
    ret =  vfprintf (stdout, format, args);                           
40005d94:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
    fprintf (stdout, "\n");                                           
40005d98:	d2 00 60 08 	ld  [ %g1 + 8 ], %o1                           <== NOT EXECUTED
40005d9c:	40 00 79 82 	call  400243a4 <fputc>                         <== NOT EXECUTED
40005da0:	90 10 20 0a 	mov  0xa, %o0                                  <== NOT EXECUTED
    fflush (stdout);                                                  
40005da4:	c2 07 61 78 	ld  [ %i5 + 0x178 ], %g1                       <== NOT EXECUTED
40005da8:	40 00 78 67 	call  40023f44 <fflush>                        <== NOT EXECUTED
40005dac:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
    va_end (args);                                                    
  }                                                                   
  return ret;                                                         
}                                                                     
40005db0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005db4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000d510 <rtems_filesystem_check_access>: int eval_flags, mode_t node_mode, uid_t node_uid, gid_t node_gid ) {
4000d510:	9d e3 bf a0 	save  %sp, -96, %sp                            
  mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;                
  uid_t task_uid = geteuid();                                         
4000d514:	7f ff fe fa 	call  4000d0fc <geteuid>                       
4000d518:	b0 0e 20 07 	and  %i0, 7, %i0                               
                                                                      
  if (task_uid == 0 || task_uid == node_uid) {                        
4000d51c:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4000d520:	91 32 20 10 	srl  %o0, 0x10, %o0                            
4000d524:	80 a2 00 1a 	cmp  %o0, %i2                                  
4000d528:	12 80 00 08 	bne  4000d548 <rtems_filesystem_check_access+0x38>
4000d52c:	80 a2 20 00 	cmp  %o0, 0                                    
    perm_flags <<= RTEMS_FS_USR_SHIFT;                                
4000d530:	b1 2e 20 06 	sll  %i0, 6, %i0                               
    } else {                                                          
      perm_flags <<= RTEMS_FS_OTH_SHIFT;                              
    }                                                                 
  }                                                                   
                                                                      
  return (perm_flags & node_mode) == perm_flags;                      
4000d534:	b0 2e 00 19 	andn  %i0, %i1, %i0                            
}                                                                     
4000d538:	80 a0 00 18 	cmp  %g0, %i0                                  
4000d53c:	b0 60 3f ff 	subx  %g0, -1, %i0                             
4000d540:	81 c7 e0 08 	ret                                            
4000d544:	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) {                        
4000d548:	22 bf ff fb 	be,a   4000d534 <rtems_filesystem_check_access+0x24>
4000d54c:	b1 2e 20 06 	sll  %i0, 6, %i0                               
    perm_flags <<= RTEMS_FS_USR_SHIFT;                                
  } else {                                                            
    gid_t task_gid = getegid();                                       
4000d550:	7f ff fe e7 	call  4000d0ec <getegid>                       
4000d554:	01 00 00 00 	nop                                            
                                                                      
    if (task_gid == 0 || task_gid == node_gid) {                      
4000d558:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4000d55c:	91 32 20 10 	srl  %o0, 0x10, %o0                            
4000d560:	80 a2 00 1b 	cmp  %o0, %i3                                  
4000d564:	12 80 00 08 	bne  4000d584 <rtems_filesystem_check_access+0x74>
4000d568:	80 a2 20 00 	cmp  %o0, 0                                    
      perm_flags <<= RTEMS_FS_GRP_SHIFT;                              
4000d56c:	b1 2e 20 03 	sll  %i0, 3, %i0                               
    } else {                                                          
      perm_flags <<= RTEMS_FS_OTH_SHIFT;                              
    }                                                                 
  }                                                                   
                                                                      
  return (perm_flags & node_mode) == perm_flags;                      
4000d570:	b0 2e 00 19 	andn  %i0, %i1, %i0                            
}                                                                     
4000d574:	80 a0 00 18 	cmp  %g0, %i0                                  
4000d578:	b0 60 3f ff 	subx  %g0, -1, %i0                             
4000d57c:	81 c7 e0 08 	ret                                            
4000d580:	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) {                      
4000d584:	32 bf ff ed 	bne,a   4000d538 <rtems_filesystem_check_access+0x28><== ALWAYS TAKEN
4000d588:	b0 2e 00 19 	andn  %i0, %i1, %i0                            
      perm_flags <<= RTEMS_FS_GRP_SHIFT;                              
4000d58c:	10 bf ff f9 	b  4000d570 <rtems_filesystem_check_access+0x60><== NOT EXECUTED
4000d590:	b1 2e 20 03 	sll  %i0, 3, %i0                               <== NOT EXECUTED
                                                                      

40005730 <rtems_filesystem_do_unmount>: } void rtems_filesystem_do_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) {
40005730:	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 );
40005734:	3b 10 00 80 	sethi  %hi(0x40020000), %i5                    
40005738:	d0 07 61 2c 	ld  [ %i5 + 0x12c ], %o0	! 4002012c <rtems_libio_semaphore>
4000573c:	92 10 20 00 	clr  %o1                                       
40005740:	40 00 0b 93 	call  4000858c <rtems_semaphore_obtain>        
40005744:	94 10 20 00 	clr  %o2                                       
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
40005748:	c4 06 00 00 	ld  [ %i0 ], %g2                               
  previous       = the_node->previous;                                
4000574c:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
40005750:	d0 07 61 2c 	ld  [ %i5 + 0x12c ], %o0                       
  next->previous = previous;                                          
40005754:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
40005758:	40 00 0b dc 	call  400086c8 <rtems_semaphore_release>       
4000575c:	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);  
40005760:	40 00 00 6d 	call  40005914 <rtems_filesystem_global_location_release>
40005764:	d0 06 20 20 	ld  [ %i0 + 0x20 ], %o0                        
  (*mt_entry->ops->fsunmount_me_h)(mt_entry);                         
40005768:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4000576c:	c2 00 60 3c 	ld  [ %g1 + 0x3c ], %g1                        
40005770:	9f c0 40 00 	call  %g1                                      
40005774:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if (mt_entry->unmount_task != 0) {                                  
40005778:	d0 06 20 3c 	ld  [ %i0 + 0x3c ], %o0                        
4000577c:	80 a2 20 00 	cmp  %o0, 0                                    
40005780:	02 80 00 07 	be  4000579c <rtems_filesystem_do_unmount+0x6c><== NEVER TAKEN
40005784:	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 ); 
40005788:	40 00 0b fb 	call  40008774 <rtems_event_system_send>       
4000578c:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
    rtems_status_code sc =                                            
      rtems_event_transient_send(mt_entry->unmount_task);             
    if (sc != RTEMS_SUCCESSFUL) {                                     
40005790:	80 a2 20 00 	cmp  %o0, 0                                    
40005794:	32 80 00 04 	bne,a   400057a4 <rtems_filesystem_do_unmount+0x74><== NEVER TAKEN
40005798:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    <== NOT EXECUTED
      rtems_fatal_error_occurred(0xdeadbeef);                         
    }                                                                 
  }                                                                   
                                                                      
  free(mt_entry);                                                     
4000579c:	7f ff fa 9b 	call  40004208 <free>                          
400057a0:	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);                         
400057a4:	40 00 0d 5f 	call  40008d20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
400057a8:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

4000d7c0 <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;
4000d7c0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
  const char *end = current + ctx->pathlen;                           
4000d7c4:	c6 02 20 04 	ld  [ %o0 + 4 ], %g3                           
4000d7c8:	86 00 40 03 	add  %g1, %g3, %g3                             
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
4000d7cc:	80 a0 40 03 	cmp  %g1, %g3                                  
4000d7d0:	32 80 00 08 	bne,a   4000d7f0 <rtems_filesystem_eval_path_eat_delimiter+0x30><== ALWAYS TAKEN
4000d7d4:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000d7d8:	10 80 00 0d 	b  4000d80c <rtems_filesystem_eval_path_eat_delimiter+0x4c><== NOT EXECUTED
4000d7dc:	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)) { 
4000d7e0:	80 a0 c0 01 	cmp  %g3, %g1                                  
4000d7e4:	22 80 00 0a 	be,a   4000d80c <rtems_filesystem_eval_path_eat_delimiter+0x4c>
4000d7e8:	86 20 c0 01 	sub  %g3, %g1, %g3                             
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
4000d7ec:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
4000d7f0:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
4000d7f4:	22 bf ff fb 	be,a   4000d7e0 <rtems_filesystem_eval_path_eat_delimiter+0x20>
4000d7f8:	82 00 60 01 	inc  %g1                                       
4000d7fc:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
4000d800:	22 bf ff f8 	be,a   4000d7e0 <rtems_filesystem_eval_path_eat_delimiter+0x20>
4000d804:	82 00 60 01 	inc  %g1                                       
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000d808:	86 20 c0 01 	sub  %g3, %g1, %g3                             
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
4000d80c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  ctx->pathlen = (size_t) (end - current);                            
4000d810:	81 c3 e0 08 	retl                                           
4000d814:	c6 22 20 04 	st  %g3, [ %o0 + 4 ]                           
                                                                      

4000d5c8 <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 ) {
4000d5c8:	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);        
4000d5cc:	03 10 00 79 	sethi  %hi(0x4001e400), %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 =              
4000d5d0:	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);        
4000d5d4:	a2 10 61 c8 	or  %g1, 0x1c8, %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);       
4000d5d8:	03 10 00 77 	sethi  %hi(0x4001dc00), %g1                    
4000d5dc:	a0 10 63 90 	or  %g1, 0x390, %l0	! 4001df90 <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);                         
4000d5e0:	40 00 00 8e 	call  4000d818 <rtems_filesystem_eval_path_next_token>
4000d5e4:	90 10 00 18 	mov  %i0, %o0                                  
  *token = ctx->token;                                                
  *tokenlen = ctx->tokenlen;                                          
4000d5e8:	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) {                                               
4000d5ec:	80 a7 60 00 	cmp  %i5, 0                                    
4000d5f0:	02 80 00 18 	be  4000d650 <rtems_filesystem_eval_path_generic+0x88>
4000d5f4:	f8 06 20 08 	ld  [ %i0 + 8 ], %i4                           
      if ((*config->is_directory)(ctx, arg)) {                        
4000d5f8:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4000d5fc:	90 10 00 18 	mov  %i0, %o0                                  
4000d600:	9f c0 40 00 	call  %g1                                      
4000d604:	92 10 00 19 	mov  %i1, %o1                                  
4000d608:	80 8a 20 ff 	btst  0xff, %o0                                
4000d60c:	02 80 00 13 	be  4000d658 <rtems_filesystem_eval_path_generic+0x90>
4000d610:	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] == '.';                           
4000d614:	02 80 00 23 	be  4000d6a0 <rtems_filesystem_eval_path_generic+0xd8>
4000d618:	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] == '.';       
4000d61c:	22 80 00 2f 	be,a   4000d6d8 <rtems_filesystem_eval_path_generic+0x110>
4000d620:	c2 4f 00 00 	ldsb  [ %i4 ], %g1                             
            }                                                         
          } else {                                                    
            status = (*config->eval_token)(ctx, arg, "..", 2);        
          }                                                           
        } else {                                                      
          status = (*config->eval_token)(ctx, arg, token, tokenlen);  
4000d624:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4000d628:	90 10 00 18 	mov  %i0, %o0                                  
4000d62c:	92 10 00 19 	mov  %i1, %o1                                  
4000d630:	94 10 00 1c 	mov  %i4, %o2                                  
4000d634:	9f c0 40 00 	call  %g1                                      
4000d638:	96 10 00 1d 	mov  %i5, %o3                                  
        }                                                             
                                                                      
        if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {  
4000d63c:	80 a2 20 02 	cmp  %o0, 2                                    
4000d640:	02 80 00 08 	be  4000d660 <rtems_filesystem_eval_path_generic+0x98>
4000d644:	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) {     
4000d648:	02 bf ff e6 	be  4000d5e0 <rtems_filesystem_eval_path_generic+0x18>
4000d64c:	01 00 00 00 	nop                                            
4000d650:	81 c7 e0 08 	ret                                            
4000d654:	81 e8 00 00 	restore                                        
              rtems_filesystem_eval_path_error(ctx, ENOENT);          
            }                                                         
          }                                                           
        }                                                             
      } else {                                                        
        rtems_filesystem_eval_path_error(ctx, ENOTDIR);               
4000d658:	7f ff de c5 	call  4000516c <rtems_filesystem_eval_path_error>
4000d65c:	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)) {             
4000d660:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000d664:	80 a0 60 00 	cmp  %g1, 0                                    
4000d668:	02 bf ff fa 	be  4000d650 <rtems_filesystem_eval_path_generic+0x88>
4000d66c:	01 00 00 00 	nop                                            
            int eval_flags;                                           
                                                                      
            rtems_filesystem_eval_path_eat_delimiter(ctx);            
4000d670:	40 00 00 54 	call  4000d7c0 <rtems_filesystem_eval_path_eat_delimiter>
4000d674:	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 
4000d678:	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 (                                                      
4000d67c:	80 88 60 80 	btst  0x80, %g1                                
4000d680:	02 80 00 06 	be  4000d698 <rtems_filesystem_eval_path_generic+0xd0>
4000d684:	01 00 00 00 	nop                                            
              (eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0 
                || rtems_filesystem_eval_path_has_path(ctx)           
4000d688:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000d68c:	80 a0 60 00 	cmp  %g1, 0                                    
4000d690:	02 bf ff f0 	be  4000d650 <rtems_filesystem_eval_path_generic+0x88>
4000d694:	01 00 00 00 	nop                                            
            ) {                                                       
              rtems_filesystem_eval_path_error(ctx, ENOENT);          
4000d698:	7f ff de b5 	call  4000516c <rtems_filesystem_eval_path_error>
4000d69c:	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] == '.';                           
4000d6a0:	c2 4f 00 00 	ldsb  [ %i4 ], %g1                             
4000d6a4:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000d6a8:	32 bf ff e0 	bne,a   4000d628 <rtems_filesystem_eval_path_generic+0x60>
4000d6ac:	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)) {             
4000d6b0:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4000d6b4:	80 a0 60 00 	cmp  %g1, 0                                    
4000d6b8:	32 80 00 2c 	bne,a   4000d768 <rtems_filesystem_eval_path_generic+0x1a0>
4000d6bc:	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) {   
4000d6c0:	c4 06 20 10 	ld  [ %i0 + 0x10 ], %g2                        
4000d6c4:	80 88 a1 00 	btst  0x100, %g2                               
4000d6c8:	22 80 00 28 	be,a   4000d768 <rtems_filesystem_eval_path_generic+0x1a0>
4000d6cc:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
              status = (*config->eval_token)(ctx, arg, ".", 1);       
            } else {                                                  
              rtems_filesystem_eval_path_error(ctx, EINVAL);          
4000d6d0:	7f ff de a7 	call  4000516c <rtems_filesystem_eval_path_error>
4000d6d4:	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] == '.';       
4000d6d8:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000d6dc:	32 bf ff d3 	bne,a   4000d628 <rtems_filesystem_eval_path_generic+0x60>
4000d6e0:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4000d6e4:	c2 4f 20 01 	ldsb  [ %i4 + 1 ], %g1                         
4000d6e8:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
4000d6ec:	32 bf ff cf 	bne,a   4000d628 <rtems_filesystem_eval_path_generic+0x60><== NEVER TAKEN
4000d6f0:	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;
4000d6f4:	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;
4000d6f8:	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 );           
4000d6fc:	c2 02 60 14 	ld  [ %o1 + 0x14 ], %g1                        
4000d700:	80 a0 80 01 	cmp  %g2, %g1                                  
4000d704:	22 80 00 27 	be,a   4000d7a0 <rtems_filesystem_eval_path_generic+0x1d8>
4000d708:	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 );      
4000d70c:	c2 00 a0 0c 	ld  [ %g2 + 0xc ], %g1                         
4000d710:	d2 00 a0 24 	ld  [ %g2 + 0x24 ], %o1                        
4000d714:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
4000d718:	9f c0 40 00 	call  %g1                                      
4000d71c:	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)) {                        
4000d720:	80 8a 20 ff 	btst  0xff, %o0                                
4000d724:	22 80 00 18 	be,a   4000d784 <rtems_filesystem_eval_path_generic+0x1bc>
4000d728:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
            if (currentloc->mt_entry->mt_point_node != NULL) {        
4000d72c:	c2 06 20 2c 	ld  [ %i0 + 0x2c ], %g1                        
4000d730:	c4 00 60 20 	ld  [ %g1 + 0x20 ], %g2                        
4000d734:	80 a0 a0 00 	cmp  %g2, 0                                    
4000d738:	22 80 00 0c 	be,a   4000d768 <rtems_filesystem_eval_path_generic+0x1a0><== NEVER TAKEN
4000d73c:	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;                                    
4000d740:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2                         
                                                                      
  ctx->path -= tokenlen;                                              
4000d744:	c6 06 00 00 	ld  [ %i0 ], %g3                               
  ctx->pathlen += tokenlen;                                           
4000d748:	c8 06 20 04 	ld  [ %i0 + 4 ], %g4                           
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  size_t tokenlen = ctx->tokenlen;                                    
                                                                      
  ctx->path -= tokenlen;                                              
4000d74c:	86 20 c0 02 	sub  %g3, %g2, %g3                             
  ctx->pathlen += tokenlen;                                           
  ctx->tokenlen = 0;                                                  
4000d750:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
)                                                                     
{                                                                     
  size_t tokenlen = ctx->tokenlen;                                    
                                                                      
  ctx->path -= tokenlen;                                              
  ctx->pathlen += tokenlen;                                           
4000d754:	84 01 00 02 	add  %g4, %g2, %g2                             
  rtems_filesystem_eval_path_context_t *ctx                           
)                                                                     
{                                                                     
  size_t tokenlen = ctx->tokenlen;                                    
                                                                      
  ctx->path -= tokenlen;                                              
4000d758:	c6 26 00 00 	st  %g3, [ %i0 ]                               
  ctx->pathlen += tokenlen;                                           
4000d75c:	c4 26 20 04 	st  %g2, [ %i0 + 4 ]                           
              rtems_filesystem_eval_path_put_back_token(ctx);         
              rtems_filesystem_eval_path_restart(                     
4000d760:	7f ff df 92 	call  400055a8 <rtems_filesystem_eval_path_restart>
4000d764:	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);         
4000d768:	90 10 00 18 	mov  %i0, %o0                                  
4000d76c:	92 10 00 19 	mov  %i1, %o1                                  
4000d770:	94 10 00 10 	mov  %l0, %o2                                  
4000d774:	9f c0 40 00 	call  %g1                                      
4000d778:	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) {  
4000d77c:	10 bf ff b1 	b  4000d640 <rtems_filesystem_eval_path_generic+0x78>
4000d780:	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);        
4000d784:	90 10 00 18 	mov  %i0, %o0                                  
4000d788:	92 10 00 19 	mov  %i1, %o1                                  
4000d78c:	94 10 00 11 	mov  %l1, %o2                                  
4000d790:	9f c0 40 00 	call  %g1                                      
4000d794:	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) {  
4000d798:	10 bf ff aa 	b  4000d640 <rtems_filesystem_eval_path_generic+0x78>
4000d79c:	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 );           
4000d7a0:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
4000d7a4:	9f c0 40 00 	call  %g1                                      
4000d7a8:	90 10 00 1b 	mov  %i3, %o0                                  
4000d7ac:	80 8a 20 ff 	btst  0xff, %o0                                
4000d7b0:	32 bf ff ee 	bne,a   4000d768 <rtems_filesystem_eval_path_generic+0x1a0>
4000d7b4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4000d7b8:	10 bf ff d5 	b  4000d70c <rtems_filesystem_eval_path_generic+0x144>
4000d7bc:	c4 06 20 2c 	ld  [ %i0 + 0x2c ], %g2                        
                                                                      

4000d818 <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;
4000d818:	c2 02 00 00 	ld  [ %o0 ], %g1                               
  const char *end = current + ctx->pathlen;                           
4000d81c:	c8 02 20 04 	ld  [ %o0 + 4 ], %g4                           
4000d820:	88 00 40 04 	add  %g1, %g4, %g4                             
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
4000d824:	80 a0 40 04 	cmp  %g1, %g4                                  
4000d828:	22 80 00 10 	be,a   4000d868 <rtems_filesystem_eval_path_next_token+0x50>
4000d82c:	88 21 00 01 	sub  %g4, %g1, %g4                             
4000d830:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
4000d834:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
4000d838:	22 80 00 08 	be,a   4000d858 <rtems_filesystem_eval_path_next_token+0x40>
4000d83c:	82 00 60 01 	inc  %g1                                       
4000d840:	10 80 00 38 	b  4000d920 <rtems_filesystem_eval_path_next_token+0x108>
4000d844:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
4000d848:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
4000d84c:	12 80 00 26 	bne  4000d8e4 <rtems_filesystem_eval_path_next_token+0xcc>
4000d850:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
    ++current;                                                        
4000d854:	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)) { 
4000d858:	80 a1 00 01 	cmp  %g4, %g1                                  
4000d85c:	32 bf ff fb 	bne,a   4000d848 <rtems_filesystem_eval_path_next_token+0x30>
4000d860:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000d864:	88 21 00 01 	sub  %g4, %g1, %g4                             
                                                                      
  while (current != end && rtems_filesystem_is_delimiter(*current)) { 
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
4000d868:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  ctx->pathlen = (size_t) (end - current);                            
4000d86c:	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;                             
4000d870:	88 00 40 04 	add  %g1, %g4, %g4                             
  const char *current = begin;                                        
                                                                      
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
4000d874:	80 a1 00 01 	cmp  %g4, %g1                                  
4000d878:	02 80 00 27 	be  4000d914 <rtems_filesystem_eval_path_next_token+0xfc>
4000d87c:	9a 10 00 01 	mov  %g1, %o5                                  
4000d880:	c4 48 40 00 	ldsb  [ %g1 ], %g2                             
4000d884:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
4000d888:	02 80 00 23 	be  4000d914 <rtems_filesystem_eval_path_next_token+0xfc><== NEVER TAKEN
4000d88c:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
4000d890:	02 80 00 22 	be  4000d918 <rtems_filesystem_eval_path_next_token+0x100><== NEVER TAKEN
4000d894:	84 10 00 01 	mov  %g1, %g2                                  
    ++current;                                                        
4000d898:	10 80 00 08 	b  4000d8b8 <rtems_filesystem_eval_path_next_token+0xa0>
4000d89c:	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)) {
4000d8a0:	80 a0 e0 5c 	cmp  %g3, 0x5c                                 
4000d8a4:	02 80 00 14 	be  4000d8f4 <rtems_filesystem_eval_path_next_token+0xdc>
4000d8a8:	80 a0 e0 2f 	cmp  %g3, 0x2f                                 
4000d8ac:	02 80 00 13 	be  4000d8f8 <rtems_filesystem_eval_path_next_token+0xe0>
4000d8b0:	9a 10 00 02 	mov  %g2, %o5                                  
    ++current;                                                        
4000d8b4:	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)) {
4000d8b8:	80 a1 00 02 	cmp  %g4, %g2                                  
4000d8bc:	32 bf ff f9 	bne,a   4000d8a0 <rtems_filesystem_eval_path_next_token+0x88>
4000d8c0:	c6 48 80 00 	ldsb  [ %g2 ], %g3                             
4000d8c4:	9a 10 00 04 	mov  %g4, %o5                                  
4000d8c8:	86 21 00 01 	sub  %g4, %g1, %g3                             
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000d8cc:	88 21 00 0d 	sub  %g4, %o5, %g4                             
                                                                      
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
4000d8d0:	c4 22 00 00 	st  %g2, [ %o0 ]                               
  ctx->pathlen = (size_t) (end - current);                            
4000d8d4:	c8 22 20 04 	st  %g4, [ %o0 + 4 ]                           
  ctx->token = begin;                                                 
4000d8d8:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
  ctx->tokenlen = (size_t) (current - begin);                         
4000d8dc:	81 c3 e0 08 	retl                                           
4000d8e0:	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)) { 
4000d8e4:	22 bf ff dd 	be,a   4000d858 <rtems_filesystem_eval_path_next_token+0x40>
4000d8e8:	82 00 60 01 	inc  %g1                                       
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000d8ec:	10 bf ff df 	b  4000d868 <rtems_filesystem_eval_path_next_token+0x50>
4000d8f0:	88 21 00 01 	sub  %g4, %g1, %g4                             
4000d8f4:	9a 10 00 02 	mov  %g2, %o5                                  
4000d8f8:	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);                            
4000d8fc:	88 21 00 0d 	sub  %g4, %o5, %g4                             
                                                                      
  while (current != end && !rtems_filesystem_is_delimiter(*current)) {
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
4000d900:	c4 22 00 00 	st  %g2, [ %o0 ]                               
  ctx->pathlen = (size_t) (end - current);                            
4000d904:	c8 22 20 04 	st  %g4, [ %o0 + 4 ]                           
  ctx->token = begin;                                                 
4000d908:	c2 22 20 08 	st  %g1, [ %o0 + 8 ]                           
  ctx->tokenlen = (size_t) (current - begin);                         
4000d90c:	81 c3 e0 08 	retl                                           
4000d910:	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)) {
4000d914:	84 10 00 01 	mov  %g1, %g2                                  
4000d918:	10 bf ff ed 	b  4000d8cc <rtems_filesystem_eval_path_next_token+0xb4>
4000d91c:	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)) { 
4000d920:	22 bf ff ce 	be,a   4000d858 <rtems_filesystem_eval_path_next_token+0x40>
4000d924:	82 00 60 01 	inc  %g1                                       
    ++current;                                                        
  }                                                                   
                                                                      
  ctx->path = current;                                                
  ctx->pathlen = (size_t) (end - current);                            
4000d928:	10 bf ff d0 	b  4000d868 <rtems_filesystem_eval_path_next_token+0x50>
4000d92c:	88 21 00 01 	sub  %g4, %g1, %g4                             
                                                                      

4000560c <rtems_filesystem_eval_path_recursive>: void rtems_filesystem_eval_path_recursive( rtems_filesystem_eval_path_context_t *ctx, const char *path, size_t pathlen ) {
4000560c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (pathlen > 0) {                                                  
40005610:	80 a6 a0 00 	cmp  %i2, 0                                    
40005614:	02 80 00 22 	be  4000569c <rtems_filesystem_eval_path_recursive+0x90><== NEVER TAKEN
40005618:	ba 10 00 18 	mov  %i0, %i5                                  
    if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {         
4000561c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
40005620:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
40005624:	14 80 00 25 	bg  400056b8 <rtems_filesystem_eval_path_recursive+0xac>
40005628:	01 00 00 00 	nop                                            
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
4000562c:	c4 4e 40 00 	ldsb  [ %i1 ], %g2                             
      const char *saved_path = ctx->path;                             
40005630:	f6 06 00 00 	ld  [ %i0 ], %i3                               
      size_t saved_pathlen = ctx->pathlen;                            
                                                                      
      if (rtems_filesystem_is_delimiter(path [0])) {                  
40005634:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
40005638:	02 80 00 1b 	be  400056a4 <rtems_filesystem_eval_path_recursive+0x98><== NEVER TAKEN
4000563c:	f8 06 20 04 	ld  [ %i0 + 4 ], %i4                           
40005640:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
40005644:	02 80 00 19 	be  400056a8 <rtems_filesystem_eval_path_recursive+0x9c>
40005648:	90 10 00 1d 	mov  %i5, %o0                                  
      }                                                               
                                                                      
      ctx->path = path;                                               
      ctx->pathlen = pathlen;                                         
                                                                      
      ++ctx->recursionlevel;                                          
4000564c:	82 00 60 01 	inc  %g1                                       
                                                                      
      if (rtems_filesystem_is_delimiter(path [0])) {                  
        rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);       
      }                                                               
                                                                      
      ctx->path = path;                                               
40005650:	f2 27 40 00 	st  %i1, [ %i5 ]                               
      ctx->pathlen = pathlen;                                         
40005654:	f4 27 60 04 	st  %i2, [ %i5 + 4 ]                           
                                                                      
      ++ctx->recursionlevel;                                          
40005658:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
      while (ctx->pathlen > 0) {                                      
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
4000565c:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
40005660:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40005664:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40005668:	9f c0 40 00 	call  %g1                                      
4000566c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      ctx->path = path;                                               
      ctx->pathlen = pathlen;                                         
                                                                      
      ++ctx->recursionlevel;                                          
      while (ctx->pathlen > 0) {                                      
40005670:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
40005674:	80 a0 60 00 	cmp  %g1, 0                                    
40005678:	32 bf ff fa 	bne,a   40005660 <rtems_filesystem_eval_path_recursive+0x54>
4000567c:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
      }                                                               
      --ctx->recursionlevel;                                          
40005680:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
      ctx->path = saved_path;                                         
40005684:	f6 27 40 00 	st  %i3, [ %i5 ]                               
                                                                      
      ++ctx->recursionlevel;                                          
      while (ctx->pathlen > 0) {                                      
        (*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);           
      }                                                               
      --ctx->recursionlevel;                                          
40005688:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
      ctx->path = saved_path;                                         
      ctx->pathlen = saved_pathlen;                                   
4000568c:	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;                                          
40005690:	c2 27 60 14 	st  %g1, [ %i5 + 0x14 ]                        
40005694:	81 c7 e0 08 	ret                                            
40005698:	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);                    
4000569c:	7f ff fe b4 	call  4000516c <rtems_filesystem_eval_path_error><== NOT EXECUTED
400056a0:	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);       
400056a4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400056a8:	7f ff ff c0 	call  400055a8 <rtems_filesystem_eval_path_restart>
400056ac:	92 07 60 30 	add  %i5, 0x30, %o1                            
400056b0:	10 bf ff e7 	b  4000564c <rtems_filesystem_eval_path_recursive+0x40>
400056b4:	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);                   
400056b8:	7f ff fe ad 	call  4000516c <rtems_filesystem_eval_path_error>
400056bc:	93 e8 20 5c 	restore  %g0, 0x5c, %o1                        
                                                                      

40005474 <rtems_filesystem_eval_path_start_with_parent>: const char *path, int eval_flags, rtems_filesystem_location_info_t *parentloc, int parent_eval_flags ) {
40005474:	9d e3 bf a0 	save  %sp, -96, %sp                            
  size_t pathlen = strlen(path);                                      
40005478:	40 00 32 97 	call  40011ed4 <strlen>                        
4000547c:	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) {                                               
40005480:	80 a2 20 00 	cmp  %o0, 0                                    
40005484:	02 80 00 32 	be  4000554c <rtems_filesystem_eval_path_start_with_parent+0xd8>
40005488:	92 10 00 19 	mov  %i1, %o1                                  
    size_t i = pathlen - 1;                                           
4000548c:	94 02 3f ff 	add  %o0, -1, %o2                              
  gid_t node_gid                                                      
);                                                                    
                                                                      
static inline bool rtems_filesystem_is_delimiter(char c)              
{                                                                     
  return c == '/' || c == '\\';                                       
40005490:	c2 4e 40 0a 	ldsb  [ %i1 + %o2 ], %g1                       
                                                                      
    if (rtems_filesystem_is_delimiter(path [i])) {                    
40005494:	80 a0 60 5c 	cmp  %g1, 0x5c                                 
40005498:	02 80 00 2a 	be  40005540 <rtems_filesystem_eval_path_start_with_parent+0xcc><== NEVER TAKEN
4000549c:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
400054a0:	12 80 00 08 	bne  400054c0 <rtems_filesystem_eval_path_start_with_parent+0x4c>
400054a4:	80 a2 a0 00 	cmp  %o2, 0                                    
400054a8:	10 80 00 27 	b  40005544 <rtems_filesystem_eval_path_start_with_parent+0xd0>
400054ac:	94 10 00 08 	mov  %o0, %o2                                  
400054b0:	02 80 00 0b 	be  400054dc <rtems_filesystem_eval_path_start_with_parent+0x68>
400054b4:	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;                                           
400054b8:	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) {                                               
400054bc:	80 a2 a0 00 	cmp  %o2, 0                                    
400054c0:	02 80 00 1a 	be  40005528 <rtems_filesystem_eval_path_start_with_parent+0xb4>
400054c4:	82 02 bf ff 	add  %o2, -1, %g1                              
400054c8:	c4 4e 40 01 	ldsb  [ %i1 + %g1 ], %g2                       
    size_t i = pathlen - 1;                                           
                                                                      
    if (rtems_filesystem_is_delimiter(path [i])) {                    
400054cc:	80 a0 a0 5c 	cmp  %g2, 0x5c                                 
400054d0:	12 bf ff f8 	bne  400054b0 <rtems_filesystem_eval_path_start_with_parent+0x3c><== ALWAYS TAKEN
400054d4:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
400054d8:	a0 22 00 0a 	sub  %o0, %o2, %l0                             <== NOT EXECUTED
      parentpath = ".";                                               
      parentpathlen = 1;                                              
      name = path;                                                    
      namelen = pathlen;                                              
    } else {                                                          
      name = path + parentpathlen;                                    
400054dc:	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;                                      
400054e0:	92 10 00 19 	mov  %i1, %o1                                  
  currentloc = eval_path_start(                                       
    ctx,                                                              
    parentpath,                                                       
    parentpathlen,                                                    
    parent_eval_flags,                                                
    &rtems_filesystem_root,                                           
400054e4:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
400054e8:	da 00 61 f0 	ld  [ %g1 + 0x1f0 ], %o5	! 4001f5f0 <rtems_current_user_env>
      name = path + parentpathlen;                                    
      namelen = pathlen - parentpathlen;                              
    }                                                                 
  }                                                                   
                                                                      
  currentloc = eval_path_start(                                       
400054ec:	96 10 00 1c 	mov  %i4, %o3                                  
400054f0:	98 03 60 04 	add  %o5, 4, %o4                               
400054f4:	7f ff ff 7a 	call  400052dc <eval_path_start>               
400054f8:	90 10 00 18 	mov  %i0, %o0                                  
400054fc:	92 10 00 08 	mov  %o0, %o1                                  
    parent_eval_flags,                                                
    &rtems_filesystem_root,                                           
    &rtems_filesystem_current                                         
  );                                                                  
                                                                      
  rtems_filesystem_location_clone(parentloc, currentloc);             
40005500:	40 00 1e b2 	call  4000cfc8 <rtems_filesystem_location_clone>
40005504:	90 10 00 1b 	mov  %i3, %o0                                  
                                                                      
  ctx->path = name;                                                   
  ctx->pathlen = namelen;                                             
  ctx->flags = eval_flags;                                            
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
40005508:	90 10 00 18 	mov  %i0, %o0                                  
    &rtems_filesystem_current                                         
  );                                                                  
                                                                      
  rtems_filesystem_location_clone(parentloc, currentloc);             
                                                                      
  ctx->path = name;                                                   
4000550c:	fa 26 00 00 	st  %i5, [ %i0 ]                               
  ctx->pathlen = namelen;                                             
40005510:	e0 26 20 04 	st  %l0, [ %i0 + 4 ]                           
  ctx->flags = eval_flags;                                            
40005514:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        
                                                                      
  rtems_filesystem_eval_path_continue(ctx);                           
40005518:	7f ff ff 54 	call  40005268 <rtems_filesystem_eval_path_continue>
4000551c:	b0 06 20 18 	add  %i0, 0x18, %i0                            
40005520:	81 c7 e0 08 	ret                                            
40005524:	81 e8 00 00 	restore                                        
  size_t namelen = 0;                                                 
  const rtems_filesystem_location_info_t *currentloc = NULL;          
                                                                      
  if (pathlen > 0) {                                                  
    if (parentpathlen == 0) {                                         
      parentpath = ".";                                               
40005528:	13 10 00 77 	sethi  %hi(0x4001dc00), %o1                    
                                                                      
#include <rtems/libio_.h>                                             
                                                                      
static size_t get_parentpathlen(const char *path, size_t pathlen)     
{                                                                     
  while (pathlen > 0) {                                               
4000552c:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
  if (pathlen > 0) {                                                  
    if (parentpathlen == 0) {                                         
      parentpath = ".";                                               
      parentpathlen = 1;                                              
      name = path;                                                    
40005530:	ba 10 00 19 	mov  %i1, %i5                                  
  const rtems_filesystem_location_info_t *currentloc = NULL;          
                                                                      
  if (pathlen > 0) {                                                  
    if (parentpathlen == 0) {                                         
      parentpath = ".";                                               
      parentpathlen = 1;                                              
40005534:	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 = ".";                                               
40005538:	10 bf ff eb 	b  400054e4 <rtems_filesystem_eval_path_start_with_parent+0x70>
4000553c:	92 12 63 90 	or  %o1, 0x390, %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])) {                    
40005540:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40005544:	10 bf ff e6 	b  400054dc <rtems_filesystem_eval_path_start_with_parent+0x68>
40005548:	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;                                                 
4000554c:	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;                                            
40005550:	ba 10 20 00 	clr  %i5                                       
    }                                                                 
                                                                      
    pathlen = i;                                                      
  }                                                                   
                                                                      
  return 0;                                                           
40005554:	10 bf ff e4 	b  400054e4 <rtems_filesystem_eval_path_start_with_parent+0x70>
40005558:	94 10 20 00 	clr  %o2                                       
                                                                      

4000d32c <rtems_filesystem_get_mount_handler>: rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) {
4000d32c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  find_arg fa = {                                                     
4000d330:	f0 27 bf f8 	st  %i0, [ %fp + -8 ]                          
4000d334:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
                                                                      
rtems_filesystem_fsmount_me_t                                         
rtems_filesystem_get_mount_handler(                                   
  const char *type                                                    
)                                                                     
{                                                                     
4000d338:	82 10 00 18 	mov  %i0, %g1                                  
  find_arg fa = {                                                     
    .type = type,                                                     
    .mount_h = NULL                                                   
  };                                                                  
                                                                      
  if ( type != NULL ) {                                               
4000d33c:	80 a0 60 00 	cmp  %g1, 0                                    
4000d340:	02 80 00 07 	be  4000d35c <rtems_filesystem_get_mount_handler+0x30><== NEVER TAKEN
4000d344:	b0 10 20 00 	clr  %i0                                       
    rtems_filesystem_iterate( find_handler, &fa );                    
4000d348:	92 07 bf f8 	add  %fp, -8, %o1                              
4000d34c:	11 10 00 34 	sethi  %hi(0x4000d000), %o0                    
4000d350:	7f ff ff c9 	call  4000d274 <rtems_filesystem_iterate>      
4000d354:	90 12 22 40 	or  %o0, 0x240, %o0	! 4000d240 <find_handler>  
4000d358:	f0 07 bf fc 	ld  [ %fp + -4 ], %i0                          
  }                                                                   
                                                                      
  return fa.mount_h;                                                  
}                                                                     
4000d35c:	81 c7 e0 08 	ret                                            
4000d360:	81 e8 00 00 	restore                                        
                                                                      

40005994 <rtems_filesystem_global_location_obtain>: } rtems_filesystem_global_location_t *rtems_filesystem_global_location_obtain( rtems_filesystem_global_location_t *const *global_loc_ptr ) {
40005994:	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) {                   
40005998:	37 10 00 7f 	sethi  %hi(0x4001fc00), %i3                    
4000599c:	c2 06 e1 30 	ld  [ %i3 + 0x130 ], %g1	! 4001fd30 <deferred_released_global_locations>
400059a0:	80 a0 60 00 	cmp  %g1, 0                                    
400059a4:	02 80 00 1e 	be  40005a1c <rtems_filesystem_global_location_obtain+0x88>
400059a8:	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;                  
400059ac:	39 10 00 80 	sethi  %hi(0x40020000), %i4                    
400059b0:	c2 07 22 b0 	ld  [ %i4 + 0x2b0 ], %g1	! 400202b0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
400059b4:	82 00 60 01 	inc  %g1                                       
    _Thread_Dispatch_disable_level = level;                           
400059b8:	c2 27 22 b0 	st  %g1, [ %i4 + 0x2b0 ]                       
                                                                      
  do {                                                                
    int count = 0;                                                    
                                                                      
    _Thread_Disable_dispatch();                                       
    current = deferred_released_global_locations;                     
400059bc:	fa 06 e1 30 	ld  [ %i3 + 0x130 ], %i5                       
    if (current != NULL) {                                            
400059c0:	80 a7 60 00 	cmp  %i5, 0                                    
400059c4:	02 80 00 14 	be  40005a14 <rtems_filesystem_global_location_obtain+0x80><== NEVER TAKEN
400059c8:	01 00 00 00 	nop                                            
400059cc:	b6 16 e1 30 	or  %i3, 0x130, %i3                            
400059d0:	b8 17 22 b0 	or  %i4, 0x2b0, %i4                            
      deferred_released_global_locations = current->deferred_released_next;
400059d4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      count = current->deferred_released_count;                       
400059d8:	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;
400059dc:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
      count = current->deferred_released_count;                       
      current->deferred_released_next = NULL;                         
400059e0:	c0 27 60 1c 	clr  [ %i5 + 0x1c ]                            
      current->deferred_released_count = 0;                           
    }                                                                 
    _Thread_Enable_dispatch();                                        
400059e4:	40 00 15 b9 	call  4000b0c8 <_Thread_Enable_dispatch>       
400059e8:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
                                                                      
    if (current != NULL) {                                            
      release_with_count(current, count);                             
400059ec:	90 10 00 1d 	mov  %i5, %o0                                  
400059f0:	7f ff ff 9e 	call  40005868 <release_with_count>            
400059f4:	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;                  
400059f8:	c2 07 00 00 	ld  [ %i4 ], %g1                               
                                                                      
    ++level;                                                          
400059fc:	82 00 60 01 	inc  %g1                                       
    _Thread_Dispatch_disable_level = level;                           
40005a00:	c2 27 00 00 	st  %g1, [ %i4 ]                               
                                                                      
  do {                                                                
    int count = 0;                                                    
                                                                      
    _Thread_Disable_dispatch();                                       
    current = deferred_released_global_locations;                     
40005a04:	fa 06 c0 00 	ld  [ %i3 ], %i5                               
    if (current != NULL) {                                            
40005a08:	80 a7 60 00 	cmp  %i5, 0                                    
40005a0c:	32 bf ff f3 	bne,a   400059d8 <rtems_filesystem_global_location_obtain+0x44><== NEVER TAKEN
40005a10:	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();                                        
40005a14:	40 00 15 ad 	call  4000b0c8 <_Thread_Enable_dispatch>       
40005a18:	01 00 00 00 	nop                                            
                                                                      
  if (deferred_released_global_locations != NULL) {                   
    deferred_release();                                               
  }                                                                   
                                                                      
  rtems_filesystem_mt_entry_lock(lock_context);                       
40005a1c:	7f ff f2 ad 	call  400024d0 <sparc_disable_interrupts>      
40005a20:	01 00 00 00 	nop                                            
40005a24:	ba 10 00 08 	mov  %o0, %i5                                  
  global_loc = *global_loc_ptr;                                       
40005a28:	f0 06 00 00 	ld  [ %i0 ], %i0                               
  if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
40005a2c:	80 a6 20 00 	cmp  %i0, 0                                    
40005a30:	02 80 00 07 	be  40005a4c <rtems_filesystem_global_location_obtain+0xb8>
40005a34:	01 00 00 00 	nop                                            
40005a38:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
40005a3c:	c2 08 60 28 	ldub  [ %g1 + 0x28 ], %g1                      
40005a40:	80 a0 60 00 	cmp  %g1, 0                                    
40005a44:	32 80 00 08 	bne,a   40005a64 <rtems_filesystem_global_location_obtain+0xd0>
40005a48:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
    global_loc = &rtems_filesystem_global_location_null;              
    errno = ENXIO;                                                    
40005a4c:	40 00 2b bd 	call  40010940 <__errno>                       
40005a50:	31 10 00 7d 	sethi  %hi(0x4001f400), %i0                    
40005a54:	82 10 20 06 	mov  6, %g1                                    
40005a58:	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;              
40005a5c:	b0 16 22 20 	or  %i0, 0x220, %i0                            
    errno = ENXIO;                                                    
  }                                                                   
  ++global_loc->reference_count;                                      
40005a60:	c2 06 20 18 	ld  [ %i0 + 0x18 ], %g1                        
40005a64:	82 00 60 01 	inc  %g1                                       
40005a68:	c2 26 20 18 	st  %g1, [ %i0 + 0x18 ]                        
  rtems_filesystem_mt_entry_unlock(lock_context);                     
40005a6c:	7f ff f2 9d 	call  400024e0 <sparc_enable_interrupts>       
40005a70:	90 10 00 1d 	mov  %i5, %o0                                  
40005a74:	81 c7 e0 08 	ret                                            
40005a78:	81 e8 00 00 	restore                                        
                                                                      

40003ee4 <rtems_filesystem_initialize>: /* * Default mode for created files. */ void rtems_filesystem_initialize( void ) {
40003ee4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
  const rtems_filesystem_mount_configuration *root_config =           
    &rtems_filesystem_root_configuration;                             
                                                                      
  rv = mount(                                                         
40003ee8:	05 10 00 75 	sethi  %hi(0x4001d400), %g2                    
40003eec:	82 10 a2 64 	or  %g2, 0x264, %g1	! 4001d664 <rtems_filesystem_root_configuration>
40003ef0:	d0 00 a2 64 	ld  [ %g2 + 0x264 ], %o0                       
40003ef4:	d2 00 60 04 	ld  [ %g1 + 4 ], %o1                           
40003ef8:	d4 00 60 08 	ld  [ %g1 + 8 ], %o2                           
40003efc:	d6 00 60 0c 	ld  [ %g1 + 0xc ], %o3                         
40003f00:	40 00 02 22 	call  40004788 <mount>                         
40003f04:	d8 00 60 10 	ld  [ %g1 + 0x10 ], %o4                        
    root_config->target,                                              
    root_config->filesystemtype,                                      
    root_config->options,                                             
    root_config->data                                                 
  );                                                                  
  if ( rv != 0 )                                                      
40003f08:	80 a2 20 00 	cmp  %o0, 0                                    
40003f0c:	12 80 00 0a 	bne  40003f34 <rtems_filesystem_initialize+0x50><== NEVER TAKEN
40003f10:	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);                                          
40003f14:	11 10 00 76 	sethi  %hi(0x4001d800), %o0                    
40003f18:	40 00 01 d3 	call  40004664 <mkdir>                         
40003f1c:	90 12 22 20 	or  %o0, 0x220, %o0	! 4001da20 <IMFS_node_control_default+0x58>
  if ( rv != 0 )                                                      
40003f20:	80 a2 20 00 	cmp  %o0, 0                                    
40003f24:	12 80 00 07 	bne  40003f40 <rtems_filesystem_initialize+0x5c><== NEVER TAKEN
40003f28:	11 2a f3 40 	sethi  %hi(0xabcd0000), %o0                    
40003f2c:	81 c7 e0 08 	ret                                            
40003f30:	81 e8 00 00 	restore                                        
    root_config->filesystemtype,                                      
    root_config->options,                                             
    root_config->data                                                 
  );                                                                  
  if ( rv != 0 )                                                      
    rtems_fatal_error_occurred( 0xABCD0002 );                         
40003f34:	11 2a f3 40 	sethi  %hi(0xabcd0000), %o0                    <== NOT EXECUTED
40003f38:	40 00 13 7a 	call  40008d20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40003f3c:	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 );                         
40003f40:	40 00 13 78 	call  40008d20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40003f44:	90 12 20 03 	or  %o0, 3, %o0                                <== NOT EXECUTED
                                                                      

4000d274 <rtems_filesystem_iterate>: bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) {
4000d274:	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 ) {                              
4000d278:	3b 10 00 75 	sethi  %hi(0x4001d400), %i5                    
4000d27c:	c2 07 62 78 	ld  [ %i5 + 0x278 ], %g1	! 4001d678 <rtems_filesystem_table>
4000d280:	80 a0 60 00 	cmp  %g1, 0                                    
4000d284:	12 80 00 06 	bne  4000d29c <rtems_filesystem_iterate+0x28>  <== ALWAYS TAKEN
4000d288:	ba 17 62 78 	or  %i5, 0x278, %i5                            
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000d28c:	10 80 00 0e 	b  4000d2c4 <rtems_filesystem_iterate+0x50>    <== NOT EXECUTED
4000d290:	35 10 00 80 	sethi  %hi(0x40020000), %i2                    <== NOT EXECUTED
4000d294:	12 80 00 24 	bne  4000d324 <rtems_filesystem_iterate+0xb0>  
4000d298:	01 00 00 00 	nop                                            
    stop = (*routine)( table_entry, routine_arg );                    
4000d29c:	90 10 00 1d 	mov  %i5, %o0                                  
4000d2a0:	9f c6 00 00 	call  %i0                                      
4000d2a4:	92 10 00 19 	mov  %i1, %o1                                  
    ++table_entry;                                                    
4000d2a8:	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 ) {                              
4000d2ac:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4000d2b0:	80 a0 60 00 	cmp  %g1, 0                                    
4000d2b4:	12 bf ff f8 	bne  4000d294 <rtems_filesystem_iterate+0x20>  
4000d2b8:	b8 8a 20 ff 	andcc  %o0, 0xff, %i4                          
    stop = (*routine)( table_entry, routine_arg );                    
    ++table_entry;                                                    
  }                                                                   
                                                                      
  if ( !stop ) {                                                      
4000d2bc:	12 80 00 1a 	bne  4000d324 <rtems_filesystem_iterate+0xb0>  
4000d2c0:	35 10 00 80 	sethi  %hi(0x40020000), %i2                    
4000d2c4:	d0 06 a1 2c 	ld  [ %i2 + 0x12c ], %o0	! 4002012c <rtems_libio_semaphore>
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000d2c8:	37 10 00 7d 	sethi  %hi(0x4001f400), %i3                    
4000d2cc:	92 10 20 00 	clr  %o1                                       
4000d2d0:	7f ff ec af 	call  4000858c <rtems_semaphore_obtain>        
4000d2d4:	94 10 20 00 	clr  %o2                                       
4000d2d8:	fa 06 e2 a0 	ld  [ %i3 + 0x2a0 ], %i5                       
4000d2dc:	b6 16 e2 a0 	or  %i3, 0x2a0, %i3                            
    rtems_libio_lock();                                               
    for (                                                             
4000d2e0:	b6 06 e0 04 	add  %i3, 4, %i3                               
4000d2e4:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000d2e8:	12 80 00 05 	bne  4000d2fc <rtems_filesystem_iterate+0x88>  
4000d2ec:	b8 10 20 00 	clr  %i4                                       
4000d2f0:	30 80 00 0b 	b,a   4000d31c <rtems_filesystem_iterate+0xa8> 
      node = rtems_chain_first( &filesystem_chain );                  
      !rtems_chain_is_tail( &filesystem_chain, node ) && !stop;       
4000d2f4:	12 80 00 0a 	bne  4000d31c <rtems_filesystem_iterate+0xa8>  <== NEVER TAKEN
4000d2f8:	01 00 00 00 	nop                                            
      node = rtems_chain_next( node )                                 
    ) {                                                               
      const filesystem_node *fsn = (filesystem_node *) node;          
                                                                      
      stop = (*routine)( &fsn->entry, routine_arg );                  
4000d2fc:	90 07 60 08 	add  %i5, 8, %o0                               
4000d300:	9f c6 00 00 	call  %i0                                      
4000d304:	92 10 00 19 	mov  %i1, %o1                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(                         
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->next;                                              
4000d308:	fa 07 40 00 	ld  [ %i5 ], %i5                               
    ++table_entry;                                                    
  }                                                                   
                                                                      
  if ( !stop ) {                                                      
    rtems_libio_lock();                                               
    for (                                                             
4000d30c:	80 a7 40 1b 	cmp  %i5, %i3                                  
4000d310:	12 bf ff f9 	bne  4000d2f4 <rtems_filesystem_iterate+0x80>  
4000d314:	b8 8a 20 ff 	andcc  %o0, 0xff, %i4                          
4000d318:	b8 0a 20 ff 	and  %o0, 0xff, %i4                            
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
4000d31c:	7f ff ec eb 	call  400086c8 <rtems_semaphore_release>       
4000d320:	d0 06 a1 2c 	ld  [ %i2 + 0x12c ], %o0                       
    }                                                                 
    rtems_libio_unlock();                                             
  }                                                                   
                                                                      
  return stop;                                                        
}                                                                     
4000d324:	81 c7 e0 08 	ret                                            
4000d328:	91 e8 00 1c 	restore  %g0, %i4, %o0                         
                                                                      

4000cfc8 <rtems_filesystem_location_clone>: void rtems_filesystem_location_clone( rtems_filesystem_location_info_t *clone, const rtems_filesystem_location_info_t *master ) {
4000cfc8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  clone = rtems_filesystem_location_copy( clone, master );            
4000cfcc:	92 10 00 19 	mov  %i1, %o1                                  
4000cfd0:	7f ff e1 bc 	call  400056c0 <rtems_filesystem_location_copy>
4000cfd4:	90 10 00 18 	mov  %i0, %o0                                  
  rv = (*clone->mt_entry->ops->clonenod_h)( clone );                  
4000cfd8:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
4000cfdc:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4000cfe0:	c2 00 60 28 	ld  [ %g1 + 0x28 ], %g1                        
4000cfe4:	9f c0 40 00 	call  %g1                                      
4000cfe8:	b0 10 00 08 	mov  %o0, %i0                                  
  if ( rv != 0 ) {                                                    
4000cfec:	80 a2 20 00 	cmp  %o0, 0                                    
4000cff0:	12 80 00 04 	bne  4000d000 <rtems_filesystem_location_clone+0x38><== NEVER TAKEN
4000cff4:	90 10 00 18 	mov  %i0, %o0                                  
4000cff8:	81 c7 e0 08 	ret                                            
4000cffc:	81 e8 00 00 	restore                                        
    rtems_filesystem_location_remove_from_mt_entry( clone );          
4000d000:	7f ff e1 ec 	call  400057b0 <rtems_filesystem_location_remove_from_mt_entry><== NOT EXECUTED
4000d004:	33 10 00 7d 	sethi  %hi(0x4001f400), %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(                              
4000d008:	7f ff e1 ae 	call  400056c0 <rtems_filesystem_location_copy><== NOT EXECUTED
4000d00c:	93 ee 62 20 	restore  %i1, 0x220, %o1                       <== NOT EXECUTED
                                                                      

400057b0 <rtems_filesystem_location_remove_from_mt_entry>: } void rtems_filesystem_location_remove_from_mt_entry( rtems_filesystem_location_info_t *loc ) {
400057b0:	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);                       
400057b4:	7f ff f3 47 	call  400024d0 <sparc_disable_interrupts>      
400057b8:	01 00 00 00 	nop                                            
  rtems_chain_extract_unprotected(&loc->mt_entry_node);               
  do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);  
400057bc:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
400057c0:	c6 06 00 00 	ld  [ %i0 ], %g3                               
  previous       = the_node->previous;                                
400057c4:	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;                    
400057c8:	c8 08 60 28 	ldub  [ %g1 + 0x28 ], %g4                      
  next->previous = previous;                                          
400057cc:	c4 20 e0 04 	st  %g2, [ %g3 + 4 ]                           
  previous->next = next;                                              
400057d0:	c6 20 80 00 	st  %g3, [ %g2 ]                               
400057d4:	80 a1 20 00 	cmp  %g4, 0                                    
400057d8:	12 80 00 07 	bne  400057f4 <rtems_filesystem_location_remove_from_mt_entry+0x44>
400057dc:	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 )     
400057e0:	c6 00 60 14 	ld  [ %g1 + 0x14 ], %g3                        
400057e4:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2                        
400057e8:	80 a0 c0 02 	cmp  %g3, %g2                                  
400057ec:	22 80 00 0b 	be,a   40005818 <rtems_filesystem_location_remove_from_mt_entry+0x68>
400057f0:	c4 00 60 24 	ld  [ %g1 + 0x24 ], %g2                        
  rtems_filesystem_mt_entry_unlock(lock_context);                     
400057f4:	7f ff f3 3b 	call  400024e0 <sparc_enable_interrupts>       
400057f8:	01 00 00 00 	nop                                            
                                                                      
  if (do_unmount) {                                                   
400057fc:	80 8f 60 ff 	btst  0xff, %i5                                
40005800:	32 80 00 04 	bne,a   40005810 <rtems_filesystem_location_remove_from_mt_entry+0x60><== NEVER TAKEN
40005804:	f0 06 20 14 	ld  [ %i0 + 0x14 ], %i0                        <== NOT EXECUTED
40005808:	81 c7 e0 08 	ret                                            
4000580c:	81 e8 00 00 	restore                                        
    rtems_filesystem_do_unmount(loc->mt_entry);                       
40005810:	7f ff ff c8 	call  40005730 <rtems_filesystem_do_unmount>   <== NOT EXECUTED
40005814:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    && mt_entry->mt_fs_root->reference_count == 1;                    
40005818:	c4 00 a0 18 	ld  [ %g2 + 0x18 ], %g2                        
4000581c:	80 a0 a0 01 	cmp  %g2, 1                                    
40005820:	12 bf ff f5 	bne  400057f4 <rtems_filesystem_location_remove_from_mt_entry+0x44><== ALWAYS TAKEN
40005824:	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 );                        
40005828:	86 00 60 18 	add  %g1, 0x18, %g3                            <== NOT EXECUTED
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
4000582c:	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;                                                  
40005830:	c6 20 60 14 	st  %g3, [ %g1 + 0x14 ]                        <== NOT EXECUTED
  head->previous = NULL;                                              
  tail->previous = head;                                              
40005834:	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                                     
40005838:	10 bf ff ef 	b  400057f4 <rtems_filesystem_location_remove_from_mt_entry+0x44><== NOT EXECUTED
4000583c:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
                                                                      

40005a7c <rtems_filesystem_location_transform_to_global>: } rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global( rtems_filesystem_location_info_t *loc ) {
40005a7c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
40005a80:	7f ff fa bc 	call  40004570 <malloc>                        
40005a84:	90 10 20 24 	mov  0x24, %o0                                 
                                                                      
  if (global_loc != NULL) {                                           
40005a88:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40005a8c:	02 80 00 0c 	be  40005abc <rtems_filesystem_location_transform_to_global+0x40><== NEVER TAKEN
40005a90:	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);       
40005a94:	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;                                  
40005a98:	c2 27 60 18 	st  %g1, [ %i5 + 0x18 ]                        
    global_loc->deferred_released_next = NULL;                        
40005a9c:	c0 27 60 1c 	clr  [ %i5 + 0x1c ]                            
    global_loc->deferred_released_count = 0;                          
    rtems_filesystem_location_copy(&global_loc->location, loc);       
40005aa0:	7f ff ff 08 	call  400056c0 <rtems_filesystem_location_copy>
40005aa4:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
    rtems_filesystem_location_remove_from_mt_entry(loc);              
40005aa8:	90 10 00 18 	mov  %i0, %o0                                  
40005aac:	7f ff ff 41 	call  400057b0 <rtems_filesystem_location_remove_from_mt_entry>
40005ab0:	b0 10 00 1d 	mov  %i5, %i0                                  
    global_loc = rtems_filesystem_global_location_obtain_null();      
    errno = ENOMEM;                                                   
  }                                                                   
                                                                      
  return global_loc;                                                  
}                                                                     
40005ab4:	81 c7 e0 08 	ret                                            
40005ab8:	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);                              
40005abc:	40 00 1d 55 	call  4000d010 <rtems_filesystem_location_free><== NOT EXECUTED
40005ac0:	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 );      
40005ac4:	90 07 bf fc 	add  %fp, -4, %o0                              <== NOT EXECUTED
40005ac8:	7f ff ff b3 	call  40005994 <rtems_filesystem_global_location_obtain><== NOT EXECUTED
40005acc:	c0 27 bf fc 	clr  [ %fp + -4 ]                              <== NOT EXECUTED
    global_loc = rtems_filesystem_global_location_obtain_null();      
    errno = ENOMEM;                                                   
40005ad0:	40 00 2b 9c 	call  40010940 <__errno>                       <== NOT EXECUTED
40005ad4:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
40005ad8:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
40005adc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return global_loc;                                                  
}                                                                     
40005ae0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005ae4:	91 e8 00 1d 	restore  %g0, %i5, %o0                         <== NOT EXECUTED
                                                                      

40004680 <rtems_filesystem_mknod>: const char *name, size_t namelen, mode_t mode, dev_t dev ) {
40004680:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
40004684:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
40004688:	c2 00 61 f0 	ld  [ %g1 + 0x1f0 ], %g1	! 4001f5f0 <rtems_current_user_env>
                                                                      
  switch (mode & S_IFMT) {                                            
4000468c:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
  dev_t dev                                                           
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
40004690:	d6 00 60 08 	ld  [ %g1 + 8 ], %o3                           
                                                                      
  switch (mode & S_IFMT) {                                            
40004694:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
  dev_t dev                                                           
)                                                                     
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
40004698:	96 2e c0 0b 	andn  %i3, %o3, %o3                            
                                                                      
  switch (mode & S_IFMT) {                                            
4000469c:	82 0a c0 01 	and  %o3, %g1, %g1                             
400046a0:	80 a0 40 02 	cmp  %g1, %g2                                  
400046a4:	22 80 00 18 	be,a   40004704 <rtems_filesystem_mknod+0x84>  
400046a8:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
400046ac:	08 80 00 0f 	bleu  400046e8 <rtems_filesystem_mknod+0x68>   
400046b0:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
400046b4:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
400046b8:	80 a0 40 02 	cmp  %g1, %g2                                  
400046bc:	02 80 00 11 	be  40004700 <rtems_filesystem_mknod+0x80>     
400046c0:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
400046c4:	80 a0 40 02 	cmp  %g1, %g2                                  
400046c8:	22 80 00 0f 	be,a   40004704 <rtems_filesystem_mknod+0x84>  <== ALWAYS TAKEN
400046cc:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    case S_IFDIR:                                                     
    case S_IFIFO:                                                     
    case S_IFREG:                                                     
      break;                                                          
    default:                                                          
      errno = EINVAL;                                                 
400046d0:	40 00 30 9c 	call  40010940 <__errno>                       
400046d4:	b0 10 3f ff 	mov  -1, %i0                                   
400046d8:	82 10 20 16 	mov  0x16, %g1                                 
400046dc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400046e0:	81 c7 e0 08 	ret                                            
400046e4:	81 e8 00 00 	restore                                        
{                                                                     
  int rv = 0;                                                         
                                                                      
  mode &= ~rtems_filesystem_umask;                                    
                                                                      
  switch (mode & S_IFMT) {                                            
400046e8:	80 a0 40 02 	cmp  %g1, %g2                                  
400046ec:	02 80 00 05 	be  40004700 <rtems_filesystem_mknod+0x80>     
400046f0:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
400046f4:	80 a0 40 02 	cmp  %g1, %g2                                  
400046f8:	12 bf ff f6 	bne  400046d0 <rtems_filesystem_mknod+0x50>    
400046fc:	01 00 00 00 	nop                                            
      rv = -1;                                                        
      break;                                                          
  }                                                                   
                                                                      
  if ( rv == 0 ) {                                                    
    const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
40004700:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
                                                                      
    rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );      
40004704:	90 10 00 18 	mov  %i0, %o0                                  
40004708:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4000470c:	92 10 00 19 	mov  %i1, %o1                                  
40004710:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
40004714:	94 10 00 1a 	mov  %i2, %o2                                  
40004718:	98 10 00 1c 	mov  %i4, %o4                                  
4000471c:	9f c0 40 00 	call  %g1                                      
40004720:	9a 10 00 1d 	mov  %i5, %o5                                  
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40004724:	81 c7 e0 08 	ret                                            
40004728:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

4000d430 <rtems_filesystem_unregister>: int rtems_filesystem_unregister( const char *type ) {
4000d430:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_chain_node *node = NULL;                                      
                                                                      
  if ( type == NULL ) {                                               
4000d434:	80 a6 20 00 	cmp  %i0, 0                                    
4000d438:	02 80 00 29 	be  4000d4dc <rtems_filesystem_unregister+0xac>
4000d43c:	37 10 00 80 	sethi  %hi(0x40020000), %i3                    
 */                                                                   
#include <rtems/userenv.h>                                            
                                                                      
static inline void rtems_libio_lock( void )                           
{                                                                     
  rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000d440:	d0 06 e1 2c 	ld  [ %i3 + 0x12c ], %o0	! 4002012c <rtems_libio_semaphore>
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4000d444:	39 10 00 7d 	sethi  %hi(0x4001f400), %i4                    
4000d448:	92 10 20 00 	clr  %o1                                       
4000d44c:	7f ff ec 50 	call  4000858c <rtems_semaphore_obtain>        
4000d450:	94 10 20 00 	clr  %o2                                       
4000d454:	fa 07 22 a0 	ld  [ %i4 + 0x2a0 ], %i5                       
4000d458:	b8 17 22 a0 	or  %i4, 0x2a0, %i4                            
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  rtems_libio_lock();                                                 
  for (                                                               
4000d45c:	b8 07 20 04 	add  %i4, 4, %i4                               
4000d460:	80 a7 40 1c 	cmp  %i5, %i4                                  
4000d464:	32 80 00 08 	bne,a   4000d484 <rtems_filesystem_unregister+0x54>
4000d468:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           
}                                                                     
                                                                      
static inline void rtems_libio_unlock( void )                         
{                                                                     
  rtems_semaphore_release( rtems_libio_semaphore );                   
4000d46c:	10 80 00 14 	b  4000d4bc <rtems_filesystem_unregister+0x8c> 
4000d470:	d0 06 e1 2c 	ld  [ %i3 + 0x12c ], %o0                       
4000d474:	80 a7 40 1c 	cmp  %i5, %i4                                  
4000d478:	02 80 00 11 	be  4000d4bc <rtems_filesystem_unregister+0x8c><== ALWAYS TAKEN
4000d47c:	d0 06 e1 2c 	ld  [ %i3 + 0x12c ], %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 ) {                     
4000d480:	d0 07 60 08 	ld  [ %i5 + 8 ], %o0                           <== NOT EXECUTED
4000d484:	40 00 10 c9 	call  400117a8 <strcmp>                        
4000d488:	92 10 00 18 	mov  %i0, %o1                                  
4000d48c:	80 a2 20 00 	cmp  %o0, 0                                    
4000d490:	32 bf ff f9 	bne,a   4000d474 <rtems_filesystem_unregister+0x44>
4000d494:	fa 07 40 00 	ld  [ %i5 ], %i5                               
 */                                                                   
RTEMS_INLINE_ROUTINE void rtems_chain_extract(                        
  rtems_chain_node *the_node                                          
)                                                                     
{                                                                     
  _Chain_Extract( the_node );                                         
4000d498:	40 00 04 40 	call  4000e598 <_Chain_Extract>                
4000d49c:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_chain_extract( node );                                    
      free( fsn );                                                    
4000d4a0:	7f ff db 5a 	call  40004208 <free>                          
4000d4a4:	90 10 00 1d 	mov  %i5, %o0                                  
4000d4a8:	d0 06 e1 2c 	ld  [ %i3 + 0x12c ], %o0                       
4000d4ac:	7f ff ec 87 	call  400086c8 <rtems_semaphore_release>       
4000d4b0:	b0 10 20 00 	clr  %i0                                       
4000d4b4:	81 c7 e0 08 	ret                                            
4000d4b8:	81 e8 00 00 	restore                                        
4000d4bc:	7f ff ec 83 	call  400086c8 <rtems_semaphore_release>       
4000d4c0:	b0 10 3f ff 	mov  -1, %i0                                   
      return 0;                                                       
    }                                                                 
  }                                                                   
  rtems_libio_unlock();                                               
                                                                      
  rtems_set_errno_and_return_minus_one( ENOENT );                     
4000d4c4:	40 00 0d 1f 	call  40010940 <__errno>                       
4000d4c8:	01 00 00 00 	nop                                            
4000d4cc:	82 10 20 02 	mov  2, %g1	! 2 <PROM_START+0x2>               
4000d4d0:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
4000d4d4:	81 c7 e0 08 	ret                                            
4000d4d8:	81 e8 00 00 	restore                                        
)                                                                     
{                                                                     
  rtems_chain_node *node = NULL;                                      
                                                                      
  if ( type == NULL ) {                                               
    rtems_set_errno_and_return_minus_one( EINVAL );                   
4000d4dc:	40 00 0d 19 	call  40010940 <__errno>                       
4000d4e0:	b0 10 3f ff 	mov  -1, %i0                                   
4000d4e4:	82 10 20 16 	mov  0x16, %g1                                 
4000d4e8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000d4ec:	81 c7 e0 08 	ret                                            
4000d4f0:	81 e8 00 00 	restore                                        
                                                                      

400047d0 <rtems_gxx_key_create>: int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) {
400047d0:	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 ) );
400047d4:	40 00 01 0c 	call  40004c04 <malloc>                        
400047d8:	90 10 20 08 	mov  8, %o0                                    
  *key = new_key;                                                     
  new_key->val  = NULL;                                               
400047dc:	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;                                                     
400047e0:	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 ) );
400047e4:	ba 10 00 08 	mov  %o0, %i5                                  
  *key = new_key;                                                     
  new_key->val  = NULL;                                               
  new_key->dtor = dtor;                                               
400047e8:	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 );
400047ec:	92 10 00 1d 	mov  %i5, %o1                                  
400047f0:	90 10 20 00 	clr  %o0                                       
400047f4:	94 10 00 19 	mov  %i1, %o2                                  
400047f8:	40 00 12 8c 	call  40009228 <rtems_task_variable_add>       
400047fc:	b0 10 20 00 	clr  %i0                                       
  if ( status == RTEMS_SUCCESSFUL )                                   
40004800:	80 a2 20 00 	cmp  %o0, 0                                    
40004804:	02 80 00 04 	be  40004814 <rtems_gxx_key_create+0x44>       <== ALWAYS TAKEN
40004808:	90 10 00 1d 	mov  %i5, %o0                                  
    return 0;                                                         
                                                                      
  free( new_key );                                                    
4000480c:	7f ff ff 81 	call  40004610 <free>                          <== NOT EXECUTED
40004810:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
  return -1;                                                          
}                                                                     
40004814:	81 c7 e0 08 	ret                                            
40004818:	81 e8 00 00 	restore                                        
                                                                      

40004828 <rtems_gxx_key_delete>: int rtems_gxx_key_delete (__gthread_key_t key) {
40004828:	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 );    
4000482c:	90 10 20 00 	clr  %o0                                       
40004830:	40 00 12 b0 	call  400092f0 <rtems_task_variable_delete>    
40004834:	92 10 00 18 	mov  %i0, %o1                                  
  if ( status == RTEMS_SUCCESSFUL ) {                                 
40004838:	80 a2 20 00 	cmp  %o0, 0                                    
4000483c:	12 80 00 06 	bne  40004854 <rtems_gxx_key_delete+0x2c>      <== NEVER TAKEN
40004840:	80 a6 20 00 	cmp  %i0, 0                                    
    /* Hmm - hopefully all tasks using this key have gone away... */  
    if ( key ) free( *(void **)key );                                 
40004844:	02 80 00 04 	be  40004854 <rtems_gxx_key_delete+0x2c>       <== NEVER TAKEN
40004848:	01 00 00 00 	nop                                            
4000484c:	7f ff ff 71 	call  40004610 <free>                          
40004850:	d0 06 00 00 	ld  [ %i0 ], %o0                               
    return 0;                                                         
  }                                                                   
  key = NULL;                                                         
  return 0;                                                           
}                                                                     
40004854:	81 c7 e0 08 	ret                                            
40004858:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

40004760 <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)) {
40004760:	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 ) {                    
40004764:	c2 06 00 00 	ld  [ %i0 ], %g1                               
40004768:	80 a0 60 00 	cmp  %g1, 0                                    
4000476c:	02 80 00 04 	be  4000477c <rtems_gxx_once+0x1c>             
40004770:	92 10 21 00 	mov  0x100, %o1                                
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
    if ( o == 0 )                                                     
      (*func)();                                                      
  }                                                                   
  return 0;                                                           
}                                                                     
40004774:	81 c7 e0 08 	ret                                            
40004778:	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); 
4000477c:	94 07 bf fc 	add  %fp, -4, %o2                              
40004780:	40 00 12 20 	call  40009000 <rtems_task_mode>               
40004784:	90 10 21 00 	mov  0x100, %o0                                
    if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {            
40004788:	c2 06 00 00 	ld  [ %i0 ], %g1                               
      *(volatile __gthread_once_t *)once = 1;                         
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
4000478c:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
40004790:	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 ) {            
40004794:	80 a0 60 00 	cmp  %g1, 0                                    
40004798:	12 80 00 0a 	bne  400047c0 <rtems_gxx_once+0x60>            <== NEVER TAKEN
4000479c:	94 07 bf fc 	add  %fp, -4, %o2                              
      *(volatile __gthread_once_t *)once = 1;                         
400047a0:	82 10 20 01 	mov  1, %g1                                    
400047a4:	c2 26 00 00 	st  %g1, [ %i0 ]                               
    }                                                                 
    rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);         
400047a8:	40 00 12 16 	call  40009000 <rtems_task_mode>               
400047ac:	b0 10 20 00 	clr  %i0                                       
    if ( o == 0 )                                                     
      (*func)();                                                      
400047b0:	9f c6 40 00 	call  %i1                                      
400047b4:	01 00 00 00 	nop                                            
  }                                                                   
  return 0;                                                           
}                                                                     
400047b8:	81 c7 e0 08 	ret                                            
400047bc:	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);         
400047c0:	40 00 12 10 	call  40009000 <rtems_task_mode>               <== NOT EXECUTED
400047c4:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
    if ( o == 0 )                                                     
      (*func)();                                                      
  }                                                                   
  return 0;                                                           
}                                                                     
400047c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400047cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400048c4 <rtems_gxx_setspecific>: #endif return p; } int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) {
400048c4:	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 );
400048c8:	d4 06 20 04 	ld  [ %i0 + 4 ], %o2                           
400048cc:	90 10 20 00 	clr  %o0                                       
400048d0:	40 00 12 56 	call  40009228 <rtems_task_variable_add>       
400048d4:	92 10 00 18 	mov  %i0, %o1                                  
  if ( status == RTEMS_SUCCESSFUL ) {                                 
400048d8:	80 a2 20 00 	cmp  %o0, 0                                    
400048dc:	12 80 00 05 	bne  400048f0 <rtems_gxx_setspecific+0x2c>     <== NEVER TAKEN
400048e0:	01 00 00 00 	nop                                            
    /* now let's set the proper value */                              
    key->val =  (void *)ptr;                                          
400048e4:	f2 26 00 00 	st  %i1, [ %i0 ]                               
    return 0;                                                         
400048e8:	81 c7 e0 08 	ret                                            
400048ec:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
  return -1;                                                          
}                                                                     
400048f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400048f4:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED
                                                                      

400097d4 <rtems_heap_allocate_aligned_with_boundary>: void *rtems_heap_allocate_aligned_with_boundary( size_t size, uintptr_t alignment, uintptr_t boundary ) {
400097d4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (                                                                
400097d8:	03 10 00 9e 	sethi  %hi(0x40027800), %g1                    
400097dc:	c2 00 62 f8 	ld  [ %g1 + 0x2f8 ], %g1	! 40027af8 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(                      
  size_t size,                                                        
  uintptr_t alignment,                                                
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
400097e0:	ba 10 00 18 	mov  %i0, %i5                                  
400097e4:	b8 10 00 19 	mov  %i1, %i4                                  
  if (                                                                
400097e8:	80 a0 60 03 	cmp  %g1, 3                                    
400097ec:	02 80 00 08 	be  4000980c <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
400097f0:	b6 10 00 1a 	mov  %i2, %i3                                  
      && !malloc_is_system_state_OK()                                 
  ) {                                                                 
    return NULL;                                                      
  }                                                                   
                                                                      
  malloc_deferred_frees_process();                                    
400097f4:	7f ff fb d4 	call  40008744 <malloc_deferred_frees_process> 
400097f8:	b2 10 00 1d 	mov  %i5, %i1                                  
                                                                      
  /* FIXME: Statistics, boundary checks */                            
                                                                      
  return _Protected_heap_Allocate_aligned_with_boundary(              
400097fc:	03 10 00 97 	sethi  %hi(0x40025c00), %g1                    
40009800:	f0 00 63 b4 	ld  [ %g1 + 0x3b4 ], %i0	! 40025fb4 <RTEMS_Malloc_Heap>
40009804:	40 00 19 77 	call  4000fde0 <_Protected_heap_Allocate_aligned_with_boundary>
40009808:	95 e8 00 1c 	restore  %g0, %i4, %o2                         
  uintptr_t boundary                                                  
)                                                                     
{                                                                     
  if (                                                                
    _System_state_Is_up( _System_state_Get() )                        
      && !malloc_is_system_state_OK()                                 
4000980c:	7f ff fb c1 	call  40008710 <malloc_is_system_state_OK>     
40009810:	01 00 00 00 	nop                                            
40009814:	80 8a 20 ff 	btst  0xff, %o0                                
40009818:	12 bf ff f7 	bne  400097f4 <rtems_heap_allocate_aligned_with_boundary+0x20>
4000981c:	b0 10 20 00 	clr  %i0                                       
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment,                                                        
    boundary                                                          
  );                                                                  
}                                                                     
40009820:	81 c7 e0 08 	ret                                            
40009824:	81 e8 00 00 	restore                                        
                                                                      

40004dc8 <rtems_heap_extend_via_sbrk>: void *rtems_heap_extend_via_sbrk( Heap_Control *heap, size_t alloc_size ) {
40004dc8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ptrdiff_t sbrk_amount = RTEMS_Malloc_Sbrk_amount;                   
40004dcc:	03 10 00 60 	sethi  %hi(0x40018000), %g1                    
40004dd0:	f8 00 60 90 	ld  [ %g1 + 0x90 ], %i4	! 40018090 <RTEMS_Malloc_Sbrk_amount>
  ptrdiff_t sbrk_size = (ptrdiff_t) alloc_size;                       
  ptrdiff_t misaligned = sbrk_size % sbrk_amount;                     
40004dd4:	90 10 00 19 	mov  %i1, %o0                                  
40004dd8:	92 10 00 1c 	mov  %i4, %o1                                  
40004ddc:	40 00 3c fc 	call  400141cc <.rem>                          
40004de0:	ba 10 00 19 	mov  %i1, %i5                                  
  void *return_this = NULL;                                           
                                                                      
  if ( misaligned != 0 ) {                                            
40004de4:	80 a2 20 00 	cmp  %o0, 0                                    
40004de8:	02 80 00 05 	be  40004dfc <rtems_heap_extend_via_sbrk+0x34> 
40004dec:	80 a7 60 00 	cmp  %i5, 0                                    
    sbrk_size += sbrk_amount - misaligned;                            
40004df0:	ba 27 00 08 	sub  %i4, %o0, %i5                             
40004df4:	ba 06 40 1d 	add  %i1, %i5, %i5                             
  }                                                                   
                                                                      
  if ( sbrk_size > 0 && sbrk_amount > 0 ) {                           
40004df8:	80 a7 60 00 	cmp  %i5, 0                                    
40004dfc:	04 80 00 17 	ble  40004e58 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40004e00:	80 a7 20 00 	cmp  %i4, 0                                    
40004e04:	04 80 00 15 	ble  40004e58 <rtems_heap_extend_via_sbrk+0x90><== NEVER TAKEN
40004e08:	01 00 00 00 	nop                                            
    void *area_begin = sbrk( sbrk_size );                             
40004e0c:	7f ff f1 b5 	call  400014e0 <sbrk>                          
40004e10:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
    if ( area_begin != (void *) -1 ) {                                
40004e14:	80 a2 3f ff 	cmp  %o0, -1                                   
40004e18:	02 80 00 10 	be  40004e58 <rtems_heap_extend_via_sbrk+0x90> 
40004e1c:	92 10 00 08 	mov  %o0, %o1                                  
      bool ok = _Protected_heap_Extend( heap, area_begin, sbrk_size );
40004e20:	90 10 00 18 	mov  %i0, %o0                                  
40004e24:	40 00 14 ad 	call  4000a0d8 <_Protected_heap_Extend>        
40004e28:	94 10 00 1d 	mov  %i5, %o2                                  
                                                                      
      if ( ok ) {                                                     
40004e2c:	80 8a 20 ff 	btst  0xff, %o0                                
40004e30:	02 80 00 08 	be  40004e50 <rtems_heap_extend_via_sbrk+0x88> 
40004e34:	03 10 00 60 	sethi  %hi(0x40018000), %g1                    
        MSBUMP( space_available, sbrk_size );                         
40004e38:	c4 00 60 60 	ld  [ %g1 + 0x60 ], %g2	! 40018060 <rtems_malloc_statistics>
40004e3c:	b4 10 20 00 	clr  %i2                                       
40004e40:	ba 07 40 02 	add  %i5, %g2, %i5                             
40004e44:	fa 20 60 60 	st  %i5, [ %g1 + 0x60 ]                        
40004e48:	40 00 14 96 	call  4000a0a0 <_Protected_heap_Allocate_aligned_with_boundary>
40004e4c:	97 e8 20 00 	restore  %g0, 0, %o3                           
                                                                      
        return_this = _Protected_heap_Allocate( heap, alloc_size );   
      } else {                                                        
        sbrk( -sbrk_size );                                           
40004e50:	7f ff f1 a4 	call  400014e0 <sbrk>                          
40004e54:	90 20 00 1d 	neg  %i5, %o0                                  
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return return_this;                                                 
}                                                                     
40004e58:	81 c7 e0 08 	ret                                            
40004e5c:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

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

40005ba8 <rtems_ide_part_table_free>: * N/A */ void rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc) { partition_table_free( disk_desc );
40005ba8:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
40005bac:	7f ff fe bb 	call  40005698 <partition_table_free>          <== NOT EXECUTED
40005bb0:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

40005bb4 <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 );
40005bb4:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
40005bb8:	7f ff ff 89 	call  400059dc <partition_table_get>           <== NOT EXECUTED
40005bbc:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

40005bc0 <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) {
40005bc0:	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));
40005bc4:	90 10 20 01 	mov  1, %o0                                    
40005bc8:	92 10 21 28 	mov  0x128, %o1                                
40005bcc:	40 00 02 2c 	call  4000647c <calloc>                        
40005bd0:	b2 10 00 18 	mov  %i0, %i1                                  
    if (disk_desc == NULL)                                            
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
40005bd4:	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)                                            
40005bd8:	80 a2 20 00 	cmp  %o0, 0                                    
40005bdc:	02 80 00 33 	be  40005ca8 <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
40005be0:	b4 10 00 08 	mov  %o0, %i2                                  
    {                                                                 
        return RTEMS_NO_MEMORY;                                       
    }                                                                 
                                                                      
    /* get partition table */                                         
    rc = partition_table_get(dev_name, disk_desc);                    
40005be4:	90 10 00 19 	mov  %i1, %o0                                  
40005be8:	7f ff ff 7d 	call  400059dc <partition_table_get>           
40005bec:	92 10 00 1a 	mov  %i2, %o1                                  
    if (rc != RTEMS_SUCCESSFUL)                                       
40005bf0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40005bf4:	12 80 00 36 	bne  40005ccc <rtems_ide_part_table_initialize+0x10c><== NEVER TAKEN
40005bf8:	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++) 
40005bfc:	c2 06 a0 24 	ld  [ %i2 + 0x24 ], %g1                        
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40005c00:	b6 07 bf f0 	add  %fp, -16, %i3                             
40005c04:	21 10 00 99 	sethi  %hi(0x40026400), %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);
40005c08:	27 10 00 99 	sethi  %hi(0x40026400), %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);                
40005c0c:	a0 14 22 a0 	or  %l0, 0x2a0, %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++) 
40005c10:	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);      
40005c14:	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);                
40005c18:	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);      
40005c1c:	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)                 
40005c20:	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);
40005c24:	29 10 00 9e 	sethi  %hi(0x40027800), %l4                    
40005c28:	a6 14 e2 a8 	or  %l3, 0x2a8, %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);                
40005c2c:	92 10 00 10 	mov  %l0, %o1                                  
40005c30:	94 10 00 19 	mov  %i1, %o2                                  
40005c34:	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++) 
40005c38:	16 80 00 1a 	bge  40005ca0 <rtems_ide_part_table_initialize+0xe0><== NEVER TAKEN
40005c3c:	96 10 00 1d 	mov  %i5, %o3                                  
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40005c40:	40 00 46 13 	call  4001748c <sprintf>                       
40005c44:	01 00 00 00 	nop                                            
        dev = rtems_filesystem_make_dev_t(major, ++minor);            
                                                                      
        part_desc = disk_desc->partitions[part_num];                  
40005c48:	c2 07 00 00 	ld  [ %i4 ], %g1                               
        if (part_desc == NULL)                                        
        {                                                             
            continue;                                                 
        }                                                             
                                                                      
        rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
40005c4c:	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)                                        
40005c50:	80 a0 60 00 	cmp  %g1, 0                                    
40005c54:	02 80 00 0a 	be  40005c7c <rtems_ide_part_table_initialize+0xbc>
40005c58:	92 07 40 11 	add  %i5, %l1, %o1                             
        {                                                             
            continue;                                                 
        }                                                             
                                                                      
        rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
40005c5c:	d8 00 60 04 	ld  [ %g1 + 4 ], %o4                           
40005c60:	da 00 60 08 	ld  [ %g1 + 8 ], %o5                           
40005c64:	d4 1e 80 00 	ldd  [ %i2 ], %o2                              
40005c68:	7f ff fd 47 	call  40005184 <rtems_disk_create_log>         
40005c6c:	f6 23 a0 5c 	st  %i3, [ %sp + 0x5c ]                        
                                   part_desc->size, name);            
        if (rc != RTEMS_SUCCESSFUL)                                   
40005c70:	96 92 20 00 	orcc  %o0, 0, %o3                              
40005c74:	12 80 00 0f 	bne  40005cb0 <rtems_ide_part_table_initialize+0xf0><== NEVER TAKEN
40005c78:	c2 05 21 c8 	ld  [ %l4 + 0x1c8 ], %g1                       
40005c7c:	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++) 
40005c80:	c2 06 a0 24 	ld  [ %i2 + 0x24 ], %g1                        
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40005c84:	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++) 
40005c88:	80 a7 40 01 	cmp  %i5, %g1                                  
    {                                                                 
        sprintf(name, "%s%d", dev_name, part_num + 1);                
40005c8c:	94 10 00 19 	mov  %i1, %o2                                  
40005c90:	ba 07 60 01 	inc  %i5                                       
40005c94:	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++) 
40005c98:	06 bf ff ea 	bl  40005c40 <rtems_ide_part_table_initialize+0x80>
40005c9c:	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);                                  
40005ca0:	7f ff fe 7e 	call  40005698 <partition_table_free>          
40005ca4:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    return RTEMS_SUCCESSFUL;                                          
}                                                                     
40005ca8:	81 c7 e0 08 	ret                                            
40005cac:	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);
40005cb0:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
40005cb4:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
40005cb8:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
40005cbc:	40 00 43 e5 	call  40016c50 <fprintf>                       <== NOT EXECUTED
40005cc0:	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++) 
40005cc4:	10 bf ff f0 	b  40005c84 <rtems_ide_part_table_initialize+0xc4><== NOT EXECUTED
40005cc8:	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);                                              
40005ccc:	40 00 02 23 	call  40006558 <free>                          <== NOT EXECUTED
40005cd0:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
40005cd4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005cd8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000a204 <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 ) {
4000a204:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
4000a208:	03 10 00 73 	sethi  %hi(0x4001cc00), %g1                    
4000a20c:	c4 00 63 b8 	ld  [ %g1 + 0x3b8 ], %g2	! 4001cfb8 <_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                  
)                                                                     
{                                                                     
4000a210:	ba 10 00 18 	mov  %i0, %i5                                  
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
4000a214:	03 10 00 74 	sethi  %hi(0x4001d000), %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                  
)                                                                     
{                                                                     
4000a218:	86 10 00 19 	mov  %i1, %g3                                  
  rtems_device_major_number major_limit = _IO_Number_of_drivers;      
4000a21c:	c8 00 63 f8 	ld  [ %g1 + 0x3f8 ], %g4                       
                                                                      
  if ( rtems_interrupt_is_in_progress() )                             
4000a220:	80 a0 a0 00 	cmp  %g2, 0                                    
4000a224:	12 80 00 1f 	bne  4000a2a0 <rtems_io_register_driver+0x9c>  
4000a228:	b0 10 20 12 	mov  0x12, %i0                                 
    return RTEMS_CALLED_FROM_ISR;                                     
                                                                      
  if ( registered_major == NULL )                                     
4000a22c:	80 a6 a0 00 	cmp  %i2, 0                                    
4000a230:	02 80 00 21 	be  4000a2b4 <rtems_io_register_driver+0xb0>   
4000a234:	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 )                                         
4000a238:	02 80 00 1f 	be  4000a2b4 <rtems_io_register_driver+0xb0>   
4000a23c:	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;
4000a240:	c4 06 40 00 	ld  [ %i1 ], %g2                               
4000a244:	80 a0 a0 00 	cmp  %g2, 0                                    
4000a248:	22 80 00 18 	be,a   4000a2a8 <rtems_io_register_driver+0xa4>
4000a24c:	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 )                                         
4000a250:	80 a1 00 1d 	cmp  %g4, %i5                                  
4000a254:	08 80 00 13 	bleu  4000a2a0 <rtems_io_register_driver+0x9c> 
4000a258:	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;                  
4000a25c:	05 10 00 72 	sethi  %hi(0x4001c800), %g2                    
4000a260:	c8 00 a2 a0 	ld  [ %g2 + 0x2a0 ], %g4	! 4001caa0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
4000a264:	88 01 20 01 	inc  %g4                                       
    _Thread_Dispatch_disable_level = level;                           
4000a268:	c8 20 a2 a0 	st  %g4, [ %g2 + 0x2a0 ]                       
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( major == 0 ) {                                                 
4000a26c:	80 a7 60 00 	cmp  %i5, 0                                    
4000a270:	02 80 00 13 	be  4000a2bc <rtems_io_register_driver+0xb8>   
4000a274:	39 10 00 74 	sethi  %hi(0x4001d000), %i4                    
      _Thread_Enable_dispatch();                                      
      return sc;                                                      
    }                                                                 
    major = *registered_major;                                        
  } else {                                                            
    rtems_driver_address_table *const table = _IO_Driver_address_table + major;
4000a278:	c8 07 23 fc 	ld  [ %i4 + 0x3fc ], %g4	! 4001d3fc <_IO_Driver_address_table>
4000a27c:	85 2f 60 03 	sll  %i5, 3, %g2                               
4000a280:	b7 2f 60 05 	sll  %i5, 5, %i3                               
4000a284:	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;
4000a288:	f2 01 00 01 	ld  [ %g4 + %g1 ], %i1                         
4000a28c:	80 a6 60 00 	cmp  %i1, 0                                    
4000a290:	02 80 00 3a 	be  4000a378 <rtems_io_register_driver+0x174>  
4000a294:	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();                                      
4000a298:	40 00 08 ec 	call  4000c648 <_Thread_Enable_dispatch>       
4000a29c:	b0 10 20 0c 	mov  0xc, %i0                                  
      return RTEMS_RESOURCE_IN_USE;                                   
4000a2a0:	81 c7 e0 08 	ret                                            
4000a2a4:	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;
4000a2a8:	80 a0 a0 00 	cmp  %g2, 0                                    
4000a2ac:	12 bf ff ea 	bne  4000a254 <rtems_io_register_driver+0x50>  
4000a2b0:	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;                                     
4000a2b4:	81 c7 e0 08 	ret                                            
4000a2b8:	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;                
4000a2bc:	c8 00 63 f8 	ld  [ %g1 + 0x3f8 ], %g4                       
  rtems_device_major_number m = 0;                                    
                                                                      
  /* major is error checked by caller */                              
                                                                      
  for ( m = 0; m < n; ++m ) {                                         
4000a2c0:	80 a1 20 00 	cmp  %g4, 0                                    
4000a2c4:	02 80 00 33 	be  4000a390 <rtems_io_register_driver+0x18c>  <== NEVER TAKEN
4000a2c8:	c2 07 23 fc 	ld  [ %i4 + 0x3fc ], %g1                       
4000a2cc:	30 80 00 04 	b,a   4000a2dc <rtems_io_register_driver+0xd8> 
4000a2d0:	80 a7 40 04 	cmp  %i5, %g4                                  
4000a2d4:	02 80 00 24 	be  4000a364 <rtems_io_register_driver+0x160>  
4000a2d8:	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;
4000a2dc:	c4 00 40 00 	ld  [ %g1 ], %g2                               
4000a2e0:	80 a0 a0 00 	cmp  %g2, 0                                    
4000a2e4:	32 bf ff fb 	bne,a   4000a2d0 <rtems_io_register_driver+0xcc>
4000a2e8:	ba 07 60 01 	inc  %i5                                       
4000a2ec:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000a2f0:	80 a0 a0 00 	cmp  %g2, 0                                    
4000a2f4:	32 bf ff f7 	bne,a   4000a2d0 <rtems_io_register_driver+0xcc>
4000a2f8:	ba 07 60 01 	inc  %i5                                       
    if ( rtems_io_is_empty_table( table ) )                           
      break;                                                          
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
4000a2fc:	fa 26 80 00 	st  %i5, [ %i2 ]                               
4000a300:	85 2f 60 03 	sll  %i5, 3, %g2                               
                                                                      
  if ( m != n )                                                       
4000a304:	80 a1 00 1d 	cmp  %g4, %i5                                  
4000a308:	02 80 00 18 	be  4000a368 <rtems_io_register_driver+0x164>  <== NEVER TAKEN
4000a30c:	b7 2f 60 05 	sll  %i5, 5, %i3                               
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
4000a310:	c8 00 c0 00 	ld  [ %g3 ], %g4                               
4000a314:	c2 07 23 fc 	ld  [ %i4 + 0x3fc ], %g1                       
4000a318:	84 26 c0 02 	sub  %i3, %g2, %g2                             
4000a31c:	c8 20 40 02 	st  %g4, [ %g1 + %g2 ]                         
4000a320:	c8 00 e0 04 	ld  [ %g3 + 4 ], %g4                           
4000a324:	82 00 40 02 	add  %g1, %g2, %g1                             
4000a328:	c8 20 60 04 	st  %g4, [ %g1 + 4 ]                           
4000a32c:	c4 00 e0 08 	ld  [ %g3 + 8 ], %g2                           
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
4000a330:	b2 10 20 00 	clr  %i1                                       
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
4000a334:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
4000a338:	c4 00 e0 0c 	ld  [ %g3 + 0xc ], %g2                         
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
4000a33c:	b4 10 20 00 	clr  %i2                                       
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
4000a340:	c4 20 60 0c 	st  %g2, [ %g1 + 0xc ]                         
4000a344:	c4 00 e0 10 	ld  [ %g3 + 0x10 ], %g2                        
                                                                      
  _Thread_Enable_dispatch();                                          
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
4000a348:	b0 10 00 1d 	mov  %i5, %i0                                  
    }                                                                 
                                                                      
    *registered_major = major;                                        
  }                                                                   
                                                                      
  _IO_Driver_address_table [major] = *driver_table;                   
4000a34c:	c4 20 60 10 	st  %g2, [ %g1 + 0x10 ]                        
4000a350:	c4 00 e0 14 	ld  [ %g3 + 0x14 ], %g2                        
                                                                      
  _Thread_Enable_dispatch();                                          
4000a354:	40 00 08 bd 	call  4000c648 <_Thread_Enable_dispatch>       
4000a358:	c4 20 60 14 	st  %g2, [ %g1 + 0x14 ]                        
                                                                      
  return rtems_io_initialize( major, 0, NULL );                       
4000a35c:	40 00 22 97 	call  40012db8 <rtems_io_initialize>           
4000a360:	81 e8 00 00 	restore                                        
    if ( rtems_io_is_empty_table( table ) )                           
      break;                                                          
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
4000a364:	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();                                      
4000a368:	40 00 08 b8 	call  4000c648 <_Thread_Enable_dispatch>       
4000a36c:	b0 10 20 05 	mov  5, %i0                                    
      return sc;                                                      
4000a370:	81 c7 e0 08 	ret                                            
4000a374:	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;
4000a378:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
4000a37c:	80 a0 60 00 	cmp  %g1, 0                                    
4000a380:	12 bf ff c6 	bne  4000a298 <rtems_io_register_driver+0x94>  
4000a384:	01 00 00 00 	nop                                            
    if ( !rtems_io_is_empty_table( table ) ) {                        
      _Thread_Enable_dispatch();                                      
      return RTEMS_RESOURCE_IN_USE;                                   
    }                                                                 
                                                                      
    *registered_major = major;                                        
4000a388:	10 bf ff e2 	b  4000a310 <rtems_io_register_driver+0x10c>   
4000a38c:	fa 26 80 00 	st  %i5, [ %i2 ]                               
    if ( rtems_io_is_empty_table( table ) )                           
      break;                                                          
  }                                                                   
                                                                      
  /* Assigns invalid value in case of failure */                      
  *major = m;                                                         
4000a390:	10 bf ff f6 	b  4000a368 <rtems_io_register_driver+0x164>   <== NOT EXECUTED
4000a394:	c0 26 80 00 	clr  [ %i2 ]                                   <== NOT EXECUTED
                                                                      

4000b360 <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) {
4000b360:	9d e3 bf a0 	save  %sp, -96, %sp                            
  uint32_t             i;                                             
  uint32_t             api_index;                                     
  Thread_Control      *the_thread;                                    
  Objects_Information *information;                                   
                                                                      
  if ( !routine )                                                     
4000b364:	80 a6 20 00 	cmp  %i0, 0                                    
4000b368:	02 80 00 20 	be  4000b3e8 <rtems_iterate_over_all_threads+0x88><== NEVER TAKEN
4000b36c:	37 10 00 8b 	sethi  %hi(0x40022c00), %i3                    
4000b370:	b6 16 e2 48 	or  %i3, 0x248, %i3	! 40022e48 <_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) 
4000b374:	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 ];       
4000b378:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4000b37c:	f8 00 60 04 	ld  [ %g1 + 4 ], %i4                           
    if ( !information )                                               
4000b380:	80 a7 20 00 	cmp  %i4, 0                                    
4000b384:	22 80 00 16 	be,a   4000b3dc <rtems_iterate_over_all_threads+0x7c>
4000b388:	b6 06 e0 04 	add  %i3, 4, %i3                               
      continue;                                                       
                                                                      
    for ( i=1 ; i <= information->maximum ; i++ ) {                   
4000b38c:	c2 17 20 10 	lduh  [ %i4 + 0x10 ], %g1                      
4000b390:	86 90 60 00 	orcc  %g1, 0, %g3                              
4000b394:	22 80 00 12 	be,a   4000b3dc <rtems_iterate_over_all_threads+0x7c>
4000b398:	b6 06 e0 04 	add  %i3, 4, %i3                               
4000b39c:	ba 10 20 01 	mov  1, %i5                                    
      the_thread = (Thread_Control *)information->local_table[ i ];   
4000b3a0:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
4000b3a4:	83 2f 60 02 	sll  %i5, 2, %g1                               
4000b3a8:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         
                                                                      
      if ( !the_thread )                                              
4000b3ac:	90 90 60 00 	orcc  %g1, 0, %o0                              
4000b3b0:	02 80 00 05 	be  4000b3c4 <rtems_iterate_over_all_threads+0x64><== NEVER TAKEN
4000b3b4:	ba 07 60 01 	inc  %i5                                       
	continue;                                                            
                                                                      
      (*routine)(the_thread);                                         
4000b3b8:	9f c6 00 00 	call  %i0                                      
4000b3bc:	01 00 00 00 	nop                                            
4000b3c0:	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++ ) {                   
4000b3c4:	83 28 e0 10 	sll  %g3, 0x10, %g1                            
4000b3c8:	83 30 60 10 	srl  %g1, 0x10, %g1                            
4000b3cc:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000b3d0:	3a bf ff f5 	bcc,a   4000b3a4 <rtems_iterate_over_all_threads+0x44>
4000b3d4:	c4 07 20 1c 	ld  [ %i4 + 0x1c ], %g2                        
4000b3d8:	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++ ) {
4000b3dc:	80 a6 c0 1a 	cmp  %i3, %i2                                  
4000b3e0:	32 bf ff e7 	bne,a   4000b37c <rtems_iterate_over_all_threads+0x1c>
4000b3e4:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4000b3e8:	81 c7 e0 08 	ret                                            
4000b3ec:	81 e8 00 00 	restore                                        
                                                                      

40004358 <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 ) {
40004358:	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)                                  
4000435c:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
40004360:	fa 00 61 a4 	ld  [ %g1 + 0x1a4 ], %i5	! 4001f5a4 <rtems_libio_number_iops>
40004364:	80 a7 60 00 	cmp  %i5, 0                                    
40004368:	02 80 00 1b 	be  400043d4 <rtems_libio_init+0x7c>           <== NEVER TAKEN
4000436c:	92 10 20 01 	mov  1, %o1                                    
    {                                                                 
        rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
40004370:	90 10 00 1d 	mov  %i5, %o0                                  
40004374:	7f ff fe f6 	call  40003f4c <calloc>                        
40004378:	92 10 20 38 	mov  0x38, %o1                                 
4000437c:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
                                                    sizeof(rtems_libio_t));
        if (rtems_libio_iops == NULL)                                 
40004380:	80 a2 20 00 	cmp  %o0, 0                                    
40004384:	02 80 00 28 	be  40004424 <rtems_libio_init+0xcc>           
40004388:	d0 20 61 24 	st  %o0, [ %g1 + 0x124 ]                       
            rtems_fatal_error_occurred(RTEMS_NO_MEMORY);              
                                                                      
        iop = rtems_libio_iop_freelist = rtems_libio_iops;            
4000438c:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
        for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)  
40004390:	80 a7 60 01 	cmp  %i5, 1                                    
40004394:	08 80 00 0e 	bleu  400043cc <rtems_libio_init+0x74>         
40004398:	d0 20 61 28 	st  %o0, [ %g1 + 0x128 ]                       
4000439c:	82 10 00 08 	mov  %o0, %g1                                  
400043a0:	84 10 20 01 	mov  1, %g2                                    
          iop->data1 = iop + 1;                                       
400043a4:	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++)  
400043a8:	84 00 a0 01 	inc  %g2                                       
400043ac:	80 a0 80 1d 	cmp  %g2, %i5                                  
400043b0:	12 bf ff fd 	bne  400043a4 <rtems_libio_init+0x4c>          
400043b4:	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 )                                         
400043b8:	84 00 bf ff 	add  %g2, -1, %g2                              
400043bc:	83 28 a0 03 	sll  %g2, 3, %g1                               
400043c0:	85 28 a0 06 	sll  %g2, 6, %g2                               
400043c4:	84 20 80 01 	sub  %g2, %g1, %g2                             
400043c8:	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;                                            
400043cc:	c0 22 20 30 	clr  [ %o0 + 0x30 ]                            
  /*                                                                  
   *  Create the binary semaphore used to provide mutual exclusion    
   *  on the IOP Table.                                               
   */                                                                 
                                                                      
  rc = rtems_semaphore_create(                                        
400043d0:	92 10 20 01 	mov  1, %o1                                    
400043d4:	11 13 10 92 	sethi  %hi(0x4c424800), %o0                    
400043d8:	94 10 20 54 	mov  0x54, %o2                                 
400043dc:	90 12 21 4f 	or  %o0, 0x14f, %o0                            
400043e0:	96 10 20 00 	clr  %o3                                       
400043e4:	19 10 00 80 	sethi  %hi(0x40020000), %o4                    
400043e8:	40 00 0f c1 	call  400082ec <rtems_semaphore_create>        
400043ec:	98 13 21 2c 	or  %o4, 0x12c, %o4	! 4002012c <rtems_libio_semaphore>
    1,                                                                
    RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, 
    RTEMS_NO_PRIORITY,                                                
    &rtems_libio_semaphore                                            
  );                                                                  
  if ( rc != RTEMS_SUCCESSFUL )                                       
400043f0:	80 a2 20 00 	cmp  %o0, 0                                    
400043f4:	12 80 00 0a 	bne  4000441c <rtems_libio_init+0xc4>          <== NEVER TAKEN
400043f8:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
                                                                      
  /*                                                                  
   *  Initialize the base file system infrastructure.                 
   */                                                                 
                                                                      
  if (rtems_fs_init_helper)                                           
400043fc:	c2 00 61 a8 	ld  [ %g1 + 0x1a8 ], %g1	! 4001f5a8 <rtems_fs_init_helper>
40004400:	80 a0 60 00 	cmp  %g1, 0                                    
40004404:	02 80 00 04 	be  40004414 <rtems_libio_init+0xbc>           
40004408:	01 00 00 00 	nop                                            
     (* rtems_fs_init_helper)();                                      
4000440c:	9f c0 40 00 	call  %g1                                      
40004410:	01 00 00 00 	nop                                            
40004414:	81 c7 e0 08 	ret                                            
40004418:	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 );                                 
4000441c:	40 00 12 41 	call  40008d20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40004420:	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);              
40004424:	40 00 12 3f 	call  40008d20 <rtems_fatal_error_occurred>    
40004428:	90 10 20 1a 	mov  0x1a, %o0	! 1a <PROM_START+0x1a>          
                                                                      

4000564c <rtems_libio_set_private_env>: } rtems_status_code rtems_libio_set_private_env(void) {
4000564c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_id self_task_id = rtems_task_self();                          
40005650:	40 00 06 73 	call  4000701c <rtems_task_self>               
40005654:	37 10 00 4d 	sethi  %hi(0x40013400), %i3                    
  rtems_user_env_t *old_env = rtems_current_user_env;                 
40005658:	fa 06 e2 08 	ld  [ %i3 + 0x208 ], %i5	! 40013608 <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;            
4000565c:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
                                                                      
  if (uses_global_env || uses_shared_env) {                           
40005660:	80 a0 40 08 	cmp  %g1, %o0                                  
40005664:	12 80 00 07 	bne  40005680 <rtems_libio_set_private_env+0x34>
40005668:	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;           
4000566c:	03 10 00 4d 	sethi  %hi(0x40013400), %g1                    
40005670:	82 10 62 0c 	or  %g1, 0x20c, %g1	! 4001360c <rtems_global_user_env>
  bool uses_shared_env = old_env->task_id != self_task_id;            
                                                                      
  if (uses_global_env || uses_shared_env) {                           
40005674:	80 a7 40 01 	cmp  %i5, %g1                                  
40005678:	12 80 00 2a 	bne  40005720 <rtems_libio_set_private_env+0xd4><== ALWAYS TAKEN
4000567c:	b0 10 20 00 	clr  %i0                                       
    rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));          
40005680:	90 10 20 01 	mov  1, %o0                                    
40005684:	92 10 20 2c 	mov  0x2c, %o1                                 
40005688:	40 00 14 a6 	call  4000a920 <calloc>                        
4000568c:	b0 10 20 1a 	mov  0x1a, %i0                                 
                                                                      
    if (new_env != NULL) {                                            
40005690:	80 a2 20 00 	cmp  %o0, 0                                    
40005694:	02 80 00 23 	be  40005720 <rtems_libio_set_private_env+0xd4>
40005698:	b4 10 00 08 	mov  %o0, %i2                                  
      *new_env = *old_env;                                            
4000569c:	92 10 00 1d 	mov  %i5, %o1                                  
400056a0:	40 00 20 b0 	call  4000d960 <memcpy>                        
400056a4:	94 10 20 2c 	mov  0x2c, %o2                                 
      new_env->reference_count = 1;                                   
400056a8:	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);
400056ac:	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;                                   
400056b0:	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);
400056b4:	40 00 03 10 	call  400062f4 <rtems_filesystem_global_location_obtain>
400056b8:	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 =                                       
400056bc:	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);
400056c0:	40 00 03 0d 	call  400062f4 <rtems_filesystem_global_location_obtain>
400056c4:	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;            
400056c8:	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 =                                    
400056cc:	d0 26 80 00 	st  %o0, [ %i2 ]                               
        rtems_filesystem_global_location_obtain(&old_env->current_directory);
                                                                      
      if (                                                            
400056d0:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
400056d4:	03 10 00 4b 	sethi  %hi(0x40012c00), %g1                    
400056d8:	82 10 62 d4 	or  %g1, 0x2d4, %g1	! 40012ed4 <rtems_filesystem_null_handlers>
400056dc:	80 a0 80 01 	cmp  %g2, %g1                                  
400056e0:	22 80 00 0e 	be,a   40005718 <rtems_libio_set_private_env+0xcc>
400056e4:	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)
400056e8:	c4 02 20 10 	ld  [ %o0 + 0x10 ], %g2                        
400056ec:	80 a0 80 01 	cmp  %g2, %g1                                  
400056f0:	02 80 00 0e 	be  40005728 <rtems_libio_set_private_env+0xdc><== NEVER TAKEN
400056f4:	90 10 20 00 	clr  %o0                                       
      ) {                                                             
        sc = rtems_task_variable_add(                                 
400056f8:	92 16 e2 08 	or  %i3, 0x208, %o1                            
400056fc:	15 10 00 15 	sethi  %hi(0x40005400), %o2                    
40005700:	40 00 06 69 	call  400070a4 <rtems_task_variable_add>       
40005704:	94 12 a1 dc 	or  %o2, 0x1dc, %o2	! 400055dc <free_user_env> 
          RTEMS_SELF,                                                 
          (void **) &rtems_current_user_env,                          
          free_user_env                                               
        );                                                            
        if (sc == RTEMS_SUCCESSFUL) {                                 
40005708:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4000570c:	02 80 00 09 	be  40005730 <rtems_libio_set_private_env+0xe4>
40005710:	01 00 00 00 	nop                                            
          free_user_env_protected(old_env);                           
          rtems_current_user_env = new_env;                           
        } else {                                                      
          sc = RTEMS_TOO_MANY;                                        
40005714:	b0 10 20 05 	mov  5, %i0	! 5 <PROM_START+0x5>               
      } else {                                                        
        sc = RTEMS_UNSATISFIED;                                       
      }                                                               
                                                                      
      if (sc != RTEMS_SUCCESSFUL) {                                   
        free_user_env(new_env);                                       
40005718:	7f ff ff b1 	call  400055dc <free_user_env>                 
4000571c:	90 10 00 1a 	mov  %i2, %o0                                  
      sc = RTEMS_NO_MEMORY;                                           
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
40005720:	81 c7 e0 08 	ret                                            
40005724:	81 e8 00 00 	restore                                        
          rtems_current_user_env = new_env;                           
        } else {                                                      
          sc = RTEMS_TOO_MANY;                                        
        }                                                             
      } else {                                                        
        sc = RTEMS_UNSATISFIED;                                       
40005728:	10 bf ff fc 	b  40005718 <rtems_libio_set_private_env+0xcc> <== NOT EXECUTED
4000572c:	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);                           
40005730:	7f ff ff be 	call  40005628 <free_user_env_protected>       
40005734:	90 10 00 1d 	mov  %i5, %o0                                  
          rtems_current_user_env = new_env;                           
40005738:	03 10 00 4d 	sethi  %hi(0x40013400), %g1                    
4000573c:	f4 20 62 08 	st  %i2, [ %g1 + 0x208 ]	! 40013608 <rtems_current_user_env>
40005740:	81 c7 e0 08 	ret                                            
40005744:	81 e8 00 00 	restore                                        
                                                                      

40005748 <rtems_libio_share_private_env>: return sc; } rtems_status_code rtems_libio_share_private_env(rtems_id task_id) {
40005748:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
  rtems_id self_task_id = rtems_task_self();                          
4000574c:	40 00 06 34 	call  4000701c <rtems_task_self>               
40005750:	01 00 00 00 	nop                                            
                                                                      
  if (task_id != RTEMS_SELF && self_task_id != task_id) {             
40005754:	80 a2 00 18 	cmp  %o0, %i0                                  
40005758:	12 80 00 04 	bne  40005768 <rtems_libio_share_private_env+0x20>
4000575c:	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;                            
40005760:	81 c7 e0 08 	ret                                            
40005764:	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) {             
40005768:	02 bf ff fe 	be  40005760 <rtems_libio_share_private_env+0x18>
4000576c:	03 10 00 50 	sethi  %hi(0x40014000), %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;                  
40005770:	c4 00 60 f0 	ld  [ %g1 + 0xf0 ], %g2	! 400140f0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
40005774:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40005778:	c4 20 60 f0 	st  %g2, [ %g1 + 0xf0 ]                        
    /*                                                                
     * We have to disable the thread dispatching to prevent deletion of the
     * environment in the meantime.                                   
     */                                                               
    _Thread_Disable_dispatch();                                       
    sc = rtems_task_variable_get(                                     
4000577c:	3b 10 00 4d 	sethi  %hi(0x40013400), %i5                    
40005780:	90 10 00 18 	mov  %i0, %o0                                  
40005784:	92 17 62 08 	or  %i5, 0x208, %o1                            
40005788:	40 00 06 a7 	call  40007224 <rtems_task_variable_get>       
4000578c:	94 07 bf fc 	add  %fp, -4, %o2                              
      task_id,                                                        
      (void *) &rtems_current_user_env,                               
      (void *) &env                                                   
    );                                                                
    if (sc == RTEMS_SUCCESSFUL) {                                     
40005790:	80 a2 20 00 	cmp  %o0, 0                                    
40005794:	12 80 00 14 	bne  400057e4 <rtems_libio_share_private_env+0x9c>
40005798:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
      ++env->reference_count;                                         
4000579c:	c4 00 60 28 	ld  [ %g1 + 0x28 ], %g2                        
400057a0:	84 00 a0 01 	inc  %g2                                       
    } else {                                                          
      sc = RTEMS_UNSATISFIED;                                         
    }                                                                 
    _Thread_Enable_dispatch();                                        
400057a4:	40 00 0f 1c 	call  40009414 <_Thread_Enable_dispatch>       
400057a8:	c4 20 60 28 	st  %g2, [ %g1 + 0x28 ]                        
                                                                      
    if (sc == RTEMS_SUCCESSFUL) {                                     
      sc = rtems_task_variable_add(                                   
400057ac:	90 10 20 00 	clr  %o0                                       
400057b0:	92 17 62 08 	or  %i5, 0x208, %o1                            
400057b4:	15 10 00 15 	sethi  %hi(0x40005400), %o2                    
400057b8:	40 00 06 3b 	call  400070a4 <rtems_task_variable_add>       
400057bc:	94 12 a1 dc 	or  %o2, 0x1dc, %o2	! 400055dc <free_user_env> 
        RTEMS_SELF,                                                   
        (void **) &rtems_current_user_env,                            
        free_user_env                                                 
      );                                                              
      if (sc == RTEMS_SUCCESSFUL) {                                   
400057c0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400057c4:	12 80 00 0c 	bne  400057f4 <rtems_libio_share_private_env+0xac><== NEVER TAKEN
400057c8:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
        free_user_env_protected(rtems_current_user_env);              
400057cc:	7f ff ff 97 	call  40005628 <free_user_env_protected>       
400057d0:	d0 07 62 08 	ld  [ %i5 + 0x208 ], %o0                       
        rtems_current_user_env = env;                                 
400057d4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400057d8:	c2 27 62 08 	st  %g1, [ %i5 + 0x208 ]                       
400057dc:	81 c7 e0 08 	ret                                            
400057e0:	81 e8 00 00 	restore                                        
    if (sc == RTEMS_SUCCESSFUL) {                                     
      ++env->reference_count;                                         
    } else {                                                          
      sc = RTEMS_UNSATISFIED;                                         
    }                                                                 
    _Thread_Enable_dispatch();                                        
400057e4:	40 00 0f 0c 	call  40009414 <_Thread_Enable_dispatch>       
400057e8:	b0 10 20 0d 	mov  0xd, %i0                                  
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400057ec:	81 c7 e0 08 	ret                                            
400057f0:	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);                                 
400057f4:	7f ff ff 8d 	call  40005628 <free_user_env_protected>       <== NOT EXECUTED
400057f8:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
400057fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005800:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4000d140 <rtems_libio_to_fcntl_flags>: int rtems_libio_to_fcntl_flags( uint32_t flags ) {
4000d140:	82 10 00 08 	mov  %o0, %g1                                  
  int fcntl_flags = 0;                                                
                                                                      
  if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 
4000d144:	84 08 60 06 	and  %g1, 6, %g2                               
4000d148:	80 a0 a0 06 	cmp  %g2, 6                                    
4000d14c:	02 80 00 05 	be  4000d160 <rtems_libio_to_fcntl_flags+0x20> 
4000d150:	90 10 20 02 	mov  2, %o0                                    
    fcntl_flags |= O_RDWR;                                            
  } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {       
4000d154:	80 88 60 02 	btst  2, %g1                                   
4000d158:	02 80 00 0e 	be  4000d190 <rtems_libio_to_fcntl_flags+0x50> <== NEVER TAKEN
4000d15c:	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 ) {     
4000d160:	80 88 60 01 	btst  1, %g1                                   
4000d164:	02 80 00 04 	be  4000d174 <rtems_libio_to_fcntl_flags+0x34> 
4000d168:	80 88 62 00 	btst  0x200, %g1                               
    fcntl_flags |= O_NONBLOCK;                                        
4000d16c:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
4000d170:	90 12 00 02 	or  %o0, %g2, %o0                              
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {         
4000d174:	32 80 00 02 	bne,a   4000d17c <rtems_libio_to_fcntl_flags+0x3c>
4000d178:	90 12 20 08 	or  %o0, 8, %o0                                
    fcntl_flags |= O_APPEND;                                          
  }                                                                   
                                                                      
  if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {         
4000d17c:	80 88 64 00 	btst  0x400, %g1                               
4000d180:	32 80 00 02 	bne,a   4000d188 <rtems_libio_to_fcntl_flags+0x48>
4000d184:	90 12 22 00 	or  %o0, 0x200, %o0                            
    fcntl_flags |= O_CREAT;                                           
  }                                                                   
                                                                      
  return fcntl_flags;                                                 
}                                                                     
4000d188:	81 c3 e0 08 	retl                                           
4000d18c:	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) {     
4000d190:	91 30 60 02 	srl  %g1, 2, %o0                               <== NOT EXECUTED
4000d194:	10 bf ff f3 	b  4000d160 <rtems_libio_to_fcntl_flags+0x20>  <== NOT EXECUTED
4000d198:	90 0a 20 01 	and  %o0, 1, %o0                               <== NOT EXECUTED
                                                                      

40005804 <rtems_libio_use_global_env>: return sc; } void rtems_libio_use_global_env(void) {
40005804:	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) {                                             
40005808:	3b 10 00 4d 	sethi  %hi(0x40013400), %i5                    
4000580c:	c2 07 62 08 	ld  [ %i5 + 0x208 ], %g1	! 40013608 <rtems_current_user_env>
40005810:	39 10 00 4d 	sethi  %hi(0x40013400), %i4                    
40005814:	b8 17 22 0c 	or  %i4, 0x20c, %i4	! 4001360c <rtems_global_user_env>
40005818:	80 a0 40 1c 	cmp  %g1, %i4                                  
4000581c:	02 80 00 08 	be  4000583c <rtems_libio_use_global_env+0x38> 
40005820:	92 17 62 08 	or  %i5, 0x208, %o1                            
    sc = rtems_task_variable_delete(                                  
40005824:	40 00 06 52 	call  4000716c <rtems_task_variable_delete>    
40005828:	90 10 20 00 	clr  %o0                                       
      RTEMS_SELF,                                                     
      (void **) &rtems_current_user_env                               
    );                                                                
    if (sc != RTEMS_SUCCESSFUL) {                                     
4000582c:	80 a2 20 00 	cmp  %o0, 0                                    
40005830:	12 80 00 05 	bne  40005844 <rtems_libio_use_global_env+0x40><== NEVER TAKEN
40005834:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
      rtems_fatal_error_occurred(0xdeadbeef);                         
    }                                                                 
                                                                      
    rtems_current_user_env = &rtems_global_user_env;                  
40005838:	f8 27 62 08 	st  %i4, [ %i5 + 0x208 ]                       
4000583c:	81 c7 e0 08 	ret                                            
40005840:	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);                         
40005844:	40 00 07 0c 	call  40007474 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40005848:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

40008aa0 <rtems_malloc_statistics_at_free>: * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) {
40008aa0:	9d e3 bf 98 	save  %sp, -104, %sp                           
  uintptr_t size;                                                     
                                                                      
  if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
40008aa4:	03 10 00 97 	sethi  %hi(0x40025c00), %g1                    
40008aa8:	d0 00 63 b4 	ld  [ %g1 + 0x3b4 ], %o0	! 40025fb4 <RTEMS_Malloc_Heap>
40008aac:	92 10 00 18 	mov  %i0, %o1                                  
40008ab0:	40 00 1c f7 	call  4000fe8c <_Protected_heap_Get_block_size>
40008ab4:	94 07 bf fc 	add  %fp, -4, %o2                              
40008ab8:	80 8a 20 ff 	btst  0xff, %o0                                
40008abc:	02 80 00 08 	be  40008adc <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
40008ac0:	03 10 00 9d 	sethi  %hi(0x40027400), %g1                    
    MSBUMP(lifetime_freed, size);                                     
40008ac4:	c8 07 bf fc 	ld  [ %fp + -4 ], %g4                          
40008ac8:	82 10 60 68 	or  %g1, 0x68, %g1                             
40008acc:	c4 18 60 28 	ldd  [ %g1 + 0x28 ], %g2                       
40008ad0:	86 80 c0 04 	addcc  %g3, %g4, %g3                           
40008ad4:	84 40 a0 00 	addx  %g2, 0, %g2                              
40008ad8:	c4 38 60 28 	std  %g2, [ %g1 + 0x28 ]                       
40008adc:	81 c7 e0 08 	ret                                            
40008ae0:	81 e8 00 00 	restore                                        
                                                                      

40008ae4 <rtems_malloc_statistics_at_malloc>: } static void rtems_malloc_statistics_at_malloc( void *pointer ) {
40008ae4:	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 )                                                     
40008ae8:	80 a6 20 00 	cmp  %i0, 0                                    
40008aec:	02 80 00 14 	be  40008b3c <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
40008af0:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
    return;                                                           
                                                                      
  _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
40008af4:	03 10 00 97 	sethi  %hi(0x40025c00), %g1                    
40008af8:	d0 00 63 b4 	ld  [ %g1 + 0x3b4 ], %o0	! 40025fb4 <RTEMS_Malloc_Heap>
40008afc:	92 10 00 18 	mov  %i0, %o1                                  
40008b00:	40 00 1c e3 	call  4000fe8c <_Protected_heap_Get_block_size>
40008b04:	94 07 bf fc 	add  %fp, -4, %o2                              
                                                                      
  MSBUMP(lifetime_allocated, actual_size);                            
40008b08:	03 10 00 9d 	sethi  %hi(0x40027400), %g1                    
40008b0c:	f8 07 bf fc 	ld  [ %fp + -4 ], %i4                          
40008b10:	82 10 60 68 	or  %g1, 0x68, %g1                             
40008b14:	c4 18 60 20 	ldd  [ %g1 + 0x20 ], %g2                       
                                                                      
  current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
40008b18:	fa 00 60 2c 	ld  [ %g1 + 0x2c ], %i5                        
  if (current_depth > s->max_depth)                                   
40008b1c:	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);                            
40008b20:	86 80 c0 1c 	addcc  %g3, %i4, %g3                           
40008b24:	84 40 a0 00 	addx  %g2, 0, %g2                              
40008b28:	c4 38 60 20 	std  %g2, [ %g1 + 0x20 ]                       
                                                                      
  current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
40008b2c:	84 20 c0 1d 	sub  %g3, %i5, %g2                             
  if (current_depth > s->max_depth)                                   
40008b30:	80 a0 80 04 	cmp  %g2, %g4                                  
40008b34:	38 80 00 02 	bgu,a   40008b3c <rtems_malloc_statistics_at_malloc+0x58>
40008b38:	c4 20 60 18 	st  %g2, [ %g1 + 0x18 ]                        
40008b3c:	81 c7 e0 08 	ret                                            
40008b40:	81 e8 00 00 	restore                                        
                                                                      

40011a14 <rtems_memalign>: int rtems_memalign( void **pointer, size_t alignment, size_t size ) {
40011a14:	9d e3 bf a0 	save  %sp, -96, %sp                            
  void *return_this;                                                  
                                                                      
  /*                                                                  
   *  Parameter error checks                                          
   */                                                                 
  if ( !pointer )                                                     
40011a18:	ba 96 20 00 	orcc  %i0, 0, %i5                              
40011a1c:	02 80 00 21 	be  40011aa0 <rtems_memalign+0x8c>             
40011a20:	03 10 00 73 	sethi  %hi(0x4001cc00), %g1                    
  *pointer = NULL;                                                    
                                                                      
  /*                                                                  
   *  Do not attempt to allocate memory if not in correct system state.
   */                                                                 
  if ( _System_state_Is_up(_System_state_Get()) &&                    
40011a24:	c2 00 63 a8 	ld  [ %g1 + 0x3a8 ], %g1	! 4001cfa8 <_System_state_Current>
40011a28:	80 a0 60 03 	cmp  %g1, 3                                    
40011a2c:	02 80 00 18 	be  40011a8c <rtems_memalign+0x78>             
40011a30:	c0 27 40 00 	clr  [ %i5 ]                                   
    return EINVAL;                                                    
                                                                      
  /*                                                                  
   *  If some free's have been deferred, then do them now.            
   */                                                                 
  malloc_deferred_frees_process();                                    
40011a34:	7f ff cf 4b 	call  40005760 <malloc_deferred_frees_process> 
40011a38:	b0 10 20 0c 	mov  0xc, %i0                                  
  Heap_Control *heap,                                                 
  uintptr_t size,                                                     
  uintptr_t alignment                                                 
)                                                                     
{                                                                     
  return                                                              
40011a3c:	03 10 00 6f 	sethi  %hi(0x4001bc00), %g1                    
40011a40:	d0 00 60 c8 	ld  [ %g1 + 0xc8 ], %o0	! 4001bcc8 <RTEMS_Malloc_Heap>
40011a44:	92 10 00 1a 	mov  %i2, %o1                                  
40011a48:	94 10 00 19 	mov  %i1, %o2                                  
40011a4c:	7f ff e7 c7 	call  4000b968 <_Protected_heap_Allocate_aligned_with_boundary>
40011a50:	96 10 20 00 	clr  %o3                                       
  return_this = _Protected_heap_Allocate_aligned(                     
    RTEMS_Malloc_Heap,                                                
    size,                                                             
    alignment                                                         
  );                                                                  
  if ( !return_this )                                                 
40011a54:	80 a2 20 00 	cmp  %o0, 0                                    
40011a58:	02 80 00 14 	be  40011aa8 <rtems_memalign+0x94>             
40011a5c:	b8 10 00 08 	mov  %o0, %i4                                  
    return ENOMEM;                                                    
                                                                      
  /*                                                                  
   *  If configured, update the more involved statistics              
   */                                                                 
  if ( rtems_malloc_statistics_helpers )                              
40011a60:	03 10 00 70 	sethi  %hi(0x4001c000), %g1                    
40011a64:	c2 00 63 d0 	ld  [ %g1 + 0x3d0 ], %g1	! 4001c3d0 <rtems_malloc_statistics_helpers>
40011a68:	80 a0 60 00 	cmp  %g1, 0                                    
40011a6c:	22 80 00 06 	be,a   40011a84 <rtems_memalign+0x70>          
40011a70:	f8 27 40 00 	st  %i4, [ %i5 ]                               
    (*rtems_malloc_statistics_helpers->at_malloc)(pointer);           
40011a74:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40011a78:	9f c0 40 00 	call  %g1                                      
40011a7c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  *pointer = return_this;                                             
40011a80:	f8 27 40 00 	st  %i4, [ %i5 ]                               
  return 0;                                                           
}                                                                     
40011a84:	81 c7 e0 08 	ret                                            
40011a88:	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() )                                 
40011a8c:	7f ff cf 28 	call  4000572c <malloc_is_system_state_OK>     
40011a90:	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()) &&                    
40011a94:	80 8a 20 ff 	btst  0xff, %o0                                
40011a98:	12 bf ff e7 	bne  40011a34 <rtems_memalign+0x20>            <== ALWAYS TAKEN
40011a9c:	01 00 00 00 	nop                                            
                                                                      
  /*                                                                  
   *  Parameter error checks                                          
   */                                                                 
  if ( !pointer )                                                     
    return EINVAL;                                                    
40011aa0:	81 c7 e0 08 	ret                                            
40011aa4:	91 e8 20 16 	restore  %g0, 0x16, %o0                        
40011aa8:	81 c7 e0 08 	ret                                            
40011aac:	81 e8 00 00 	restore                                        
                                                                      

4000a56c <rtems_mkdir>: return (retval); } int rtems_mkdir(const char *path, mode_t mode) {
4000a56c:	9d e3 bf 58 	save  %sp, -168, %sp                           
  int success = 0;                                                    
  char *dup_path = strdup(path);                                      
4000a570:	40 00 6d b5 	call  40025c44 <strdup>                        
4000a574:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  if (dup_path != NULL) {                                             
4000a578:	b6 92 20 00 	orcc  %o0, 0, %i3                              
4000a57c:	02 80 00 69 	be  4000a720 <rtems_mkdir+0x1b4>               
4000a580:	01 00 00 00 	nop                                            
  char *p;                                                            
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
4000a584:	c2 0e c0 00 	ldub  [ %i3 ], %g1                             
4000a588:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4000a58c:	85 38 60 18 	sra  %g1, 0x18, %g2                            
4000a590:	80 a0 a0 2f 	cmp  %g2, 0x2f                                 
4000a594:	02 80 00 57 	be  4000a6f0 <rtems_mkdir+0x184>               
4000a598:	ba 10 00 1b 	mov  %i3, %i5                                  
    ++p;                                                              
  for (first = 1, last = 0; !last ; ++p) {                            
    if (p[0] == '\0')                                                 
4000a59c:	83 38 60 18 	sra  %g1, 0x18, %g1                            
  char *p;                                                            
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
4000a5a0:	b4 10 20 00 	clr  %i2                                       
4000a5a4:	84 10 20 01 	mov  1, %g2                                    
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
4000a5a8:	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)) {                            
4000a5ac:	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')                                                 
4000a5b0:	80 a0 60 00 	cmp  %g1, 0                                    
4000a5b4:	02 80 00 0b 	be  4000a5e0 <rtems_mkdir+0x74>                <== NEVER TAKEN
4000a5b8:	21 00 00 10 	sethi  %hi(0x4000), %l0                        
      last = 1;                                                       
    else if (p[0] != '/')                                             
4000a5bc:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
4000a5c0:	22 80 00 2f 	be,a   4000a67c <rtems_mkdir+0x110>            
4000a5c4:	c2 4f 60 01 	ldsb  [ %i5 + 1 ], %g1                         
4000a5c8:	c2 0f 60 01 	ldub  [ %i5 + 1 ], %g1                         
4000a5cc:	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')                                                 
4000a5d0:	83 38 60 18 	sra  %g1, 0x18, %g1                            
4000a5d4:	80 a0 60 00 	cmp  %g1, 0                                    
4000a5d8:	12 bf ff f9 	bne  4000a5bc <rtems_mkdir+0x50>               
4000a5dc:	ba 07 60 01 	inc  %i5                                       
      last = 1;                                                       
    else if (p[0] != '/')                                             
      continue;                                                       
    *p = '\0';                                                        
4000a5e0:	c0 2f 40 00 	clrb  [ %i5 ]                                  
4000a5e4:	b8 10 20 01 	mov  1, %i4                                    
    if (!last && p[1] == '\0')                                        
      last = 1;                                                       
    if (first) {                                                      
4000a5e8:	80 a0 a0 00 	cmp  %g2, 0                                    
4000a5ec:	12 80 00 1d 	bne  4000a660 <rtems_mkdir+0xf4>               
4000a5f0:	01 00 00 00 	nop                                            
      oumask = umask(0);                                              
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
4000a5f4:	80 a7 20 00 	cmp  %i4, 0                                    
4000a5f8:	12 80 00 0a 	bne  4000a620 <rtems_mkdir+0xb4>               
4000a5fc:	90 10 00 1b 	mov  %i3, %o0                                  
      (void)umask(oumask);                                            
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4000a600:	7f ff fc a4 	call  40009890 <mkdir>                         
4000a604:	92 10 21 ff 	mov  0x1ff, %o1                                
4000a608:	80 a2 20 00 	cmp  %o0, 0                                    
4000a60c:	06 80 00 20 	bl  4000a68c <rtems_mkdir+0x120>               
4000a610:	01 00 00 00 	nop                                            
        retval = 0;                                                   
        break;                                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
4000a614:	f0 2f 40 00 	stb  %i0, [ %i5 ]                              
4000a618:	10 bf ff ec 	b  4000a5c8 <rtems_mkdir+0x5c>                 
4000a61c:	84 10 20 00 	clr  %g2                                       
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
      (void)umask(oumask);                                            
4000a620:	40 00 0a a8 	call  4000d0c0 <umask>                         
4000a624:	90 10 00 1a 	mov  %i2, %o0                                  
    if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
4000a628:	90 10 00 1b 	mov  %i3, %o0                                  
4000a62c:	7f ff fc 99 	call  40009890 <mkdir>                         
4000a630:	92 10 00 19 	mov  %i1, %o1                                  
4000a634:	80 a2 20 00 	cmp  %o0, 0                                    
4000a638:	06 80 00 15 	bl  4000a68c <rtems_mkdir+0x120>               
4000a63c:	01 00 00 00 	nop                                            
4000a640:	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);                                                   
4000a644:	7f ff fa b9 	call  40009128 <free>                          
4000a648:	90 10 00 1b 	mov  %i3, %o0                                  
  }                                                                   
                                                                      
  return success != 0 ? 0 : -1;                                       
4000a64c:	80 a7 60 00 	cmp  %i5, 0                                    
4000a650:	02 80 00 34 	be  4000a720 <rtems_mkdir+0x1b4>               <== NEVER TAKEN
4000a654:	b0 10 20 00 	clr  %i0                                       
}                                                                     
4000a658:	81 c7 e0 08 	ret                                            
4000a65c:	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);                                              
4000a660:	40 00 0a 98 	call  4000d0c0 <umask>                         
4000a664:	90 10 20 00 	clr  %o0                                       
4000a668:	b4 10 00 08 	mov  %o0, %i2                                  
      numask = oumask & ~(S_IWUSR | S_IXUSR);                         
      (void)umask(numask);                                            
4000a66c:	40 00 0a 95 	call  4000d0c0 <umask>                         
4000a670:	90 0a 3f 3f 	and  %o0, -193, %o0                            
      first = 0;                                                      
    }                                                                 
    if (last)                                                         
4000a674:	10 bf ff e1 	b  4000a5f8 <rtems_mkdir+0x8c>                 
4000a678:	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';                                                        
4000a67c:	c0 2f 40 00 	clrb  [ %i5 ]                                  
4000a680:	80 a0 00 01 	cmp  %g0, %g1                                  
4000a684:	10 bf ff d9 	b  4000a5e8 <rtems_mkdir+0x7c>                 
4000a688:	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) {                       
4000a68c:	40 00 65 2b 	call  40023b38 <__errno>                       
4000a690:	01 00 00 00 	nop                                            
4000a694:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000a698:	80 a0 60 11 	cmp  %g1, 0x11                                 
4000a69c:	02 80 00 08 	be  4000a6bc <rtems_mkdir+0x150>               
4000a6a0:	90 10 00 1b 	mov  %i3, %o0                                  
4000a6a4:	40 00 65 25 	call  40023b38 <__errno>                       
4000a6a8:	01 00 00 00 	nop                                            
4000a6ac:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000a6b0:	80 a0 60 15 	cmp  %g1, 0x15                                 
4000a6b4:	12 80 00 28 	bne  4000a754 <rtems_mkdir+0x1e8>              <== ALWAYS TAKEN
4000a6b8:	90 10 00 1b 	mov  %i3, %o0                                  
        if (stat(path, &sb) < 0) {                                    
4000a6bc:	40 00 00 2a 	call  4000a764 <stat>                          
4000a6c0:	92 07 bf b8 	add  %fp, -72, %o1                             
4000a6c4:	80 a2 20 00 	cmp  %o0, 0                                    
4000a6c8:	06 80 00 23 	bl  4000a754 <rtems_mkdir+0x1e8>               <== NEVER TAKEN
4000a6cc:	c2 07 bf c4 	ld  [ %fp + -60 ], %g1                         
          retval = 0;                                                 
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
4000a6d0:	82 08 40 11 	and  %g1, %l1, %g1                             
4000a6d4:	80 a0 40 10 	cmp  %g1, %l0                                  
4000a6d8:	12 80 00 0a 	bne  4000a700 <rtems_mkdir+0x194>              
4000a6dc:	80 a7 20 00 	cmp  %i4, 0                                    
          else                                                        
            errno = ENOTDIR;                                          
          retval = 0;                                                 
          break;                                                      
        }                                                             
        if (last)                                                     
4000a6e0:	22 bf ff ce 	be,a   4000a618 <rtems_mkdir+0xac>             
4000a6e4:	f0 2f 40 00 	stb  %i0, [ %i5 ]                              
          retval = 2;                                                 
4000a6e8:	10 bf ff d7 	b  4000a644 <rtems_mkdir+0xd8>                 
4000a6ec:	ba 10 20 02 	mov  2, %i5                                    
4000a6f0:	c2 0e e0 01 	ldub  [ %i3 + 1 ], %g1                         
                                                                      
  p = path;                                                           
  oumask = 0;                                                         
  retval = 1;                                                         
  if (p[0] == '/')    /* Skip leading '/'. */                         
    ++p;                                                              
4000a6f4:	ba 06 e0 01 	add  %i3, 1, %i5                               
4000a6f8:	10 bf ff a9 	b  4000a59c <rtems_mkdir+0x30>                 
4000a6fc:	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)                                                   
4000a700:	02 80 00 0a 	be  4000a728 <rtems_mkdir+0x1bc>               
4000a704:	01 00 00 00 	nop                                            
            errno = EEXIST;                                           
4000a708:	40 00 65 0c 	call  40023b38 <__errno>                       
4000a70c:	01 00 00 00 	nop                                            
4000a710:	82 10 20 11 	mov  0x11, %g1	! 11 <PROM_START+0x11>          
4000a714:	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);                                                   
4000a718:	7f ff fa 84 	call  40009128 <free>                          
4000a71c:	90 10 00 1b 	mov  %i3, %o0                                  
  }                                                                   
                                                                      
  return success != 0 ? 0 : -1;                                       
4000a720:	81 c7 e0 08 	ret                                            
4000a724:	91 e8 3f ff 	restore  %g0, -1, %o0                          
          break;                                                      
        } else if (!S_ISDIR(sb.st_mode)) {                            
          if (last)                                                   
            errno = EEXIST;                                           
          else                                                        
            errno = ENOTDIR;                                          
4000a728:	40 00 65 04 	call  40023b38 <__errno>                       
4000a72c:	01 00 00 00 	nop                                            
4000a730:	82 10 20 14 	mov  0x14, %g1	! 14 <PROM_START+0x14>          
4000a734:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
  }                                                                   
  if (!first && !last)                                                
    (void)umask(oumask);                                              
4000a738:	40 00 0a 62 	call  4000d0c0 <umask>                         
4000a73c:	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);                                                   
4000a740:	90 10 00 1b 	mov  %i3, %o0                                  
4000a744:	7f ff fa 79 	call  40009128 <free>                          
4000a748:	b0 10 3f ff 	mov  -1, %i0                                   
4000a74c:	81 c7 e0 08 	ret                                            
4000a750:	81 e8 00 00 	restore                                        
      }                                                               
    }                                                                 
    if (!last)                                                        
        *p = '/';                                                     
  }                                                                   
  if (!first && !last)                                                
4000a754:	80 a7 20 00 	cmp  %i4, 0                                    
4000a758:	02 bf ff f8 	be  4000a738 <rtems_mkdir+0x1cc>               <== NEVER TAKEN
4000a75c:	90 10 00 1b 	mov  %i3, %o0                                  
4000a760:	30 bf ff f9 	b,a   4000a744 <rtems_mkdir+0x1d8>             
                                                                      

40009f68 <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 ) {
40009f68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int                  i;                                             
                                                                      
  /*                                                                  
   * Validate parameters and look up information structure.           
   */                                                                 
  if ( !info )                                                        
40009f6c:	80 a6 a0 00 	cmp  %i2, 0                                    
40009f70:	02 80 00 21 	be  40009ff4 <rtems_object_get_class_information+0x8c>
40009f74:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  obj_info = _Objects_Get_information( the_api, the_class );          
40009f78:	93 2e 60 10 	sll  %i1, 0x10, %o1                            
40009f7c:	90 10 00 18 	mov  %i0, %o0                                  
40009f80:	40 00 07 cc 	call  4000beb0 <_Objects_Get_information>      
40009f84:	93 32 60 10 	srl  %o1, 0x10, %o1                            
  if ( !obj_info )                                                    
40009f88:	80 a2 20 00 	cmp  %o0, 0                                    
40009f8c:	02 80 00 1a 	be  40009ff4 <rtems_object_get_class_information+0x8c>
40009f90:	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;                              
40009f94:	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;                           
40009f98:	c6 02 20 08 	ld  [ %o0 + 8 ], %g3                           
  info->maximum_id  = obj_info->maximum_id;                           
40009f9c:	c4 02 20 0c 	ld  [ %o0 + 0xc ], %g2                         
  info->auto_extend = obj_info->auto_extend;                          
40009fa0:	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;                           
40009fa4:	c6 26 80 00 	st  %g3, [ %i2 ]                               
  info->maximum_id  = obj_info->maximum_id;                           
40009fa8:	c4 26 a0 04 	st  %g2, [ %i2 + 4 ]                           
  info->auto_extend = obj_info->auto_extend;                          
40009fac:	c2 2e a0 0c 	stb  %g1, [ %i2 + 0xc ]                        
  info->maximum     = obj_info->maximum;                              
                                                                      
  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )               
40009fb0:	80 a1 20 00 	cmp  %g4, 0                                    
40009fb4:	02 80 00 12 	be  40009ffc <rtems_object_get_class_information+0x94><== NEVER TAKEN
40009fb8:	c8 26 a0 08 	st  %g4, [ %i2 + 8 ]                           
40009fbc:	fa 02 20 1c 	ld  [ %o0 + 0x1c ], %i5                        
40009fc0:	86 10 20 01 	mov  1, %g3                                    
40009fc4:	82 10 20 01 	mov  1, %g1                                    
40009fc8:	84 10 20 00 	clr  %g2                                       
    if ( !obj_info->local_table[i] )                                  
40009fcc:	87 28 e0 02 	sll  %g3, 2, %g3                               
40009fd0:	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++ )               
40009fd4:	82 00 60 01 	inc  %g1                                       
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
40009fd8:	80 a0 00 03 	cmp  %g0, %g3                                  
40009fdc:	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++ )               
40009fe0:	80 a1 00 01 	cmp  %g4, %g1                                  
40009fe4:	1a bf ff fa 	bcc  40009fcc <rtems_object_get_class_information+0x64>
40009fe8:	86 10 00 01 	mov  %g1, %g3                                  
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
                                                                      
  info->unallocated = unallocated;                                    
40009fec:	c4 26 a0 10 	st  %g2, [ %i2 + 0x10 ]                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40009ff0:	82 10 20 00 	clr  %g1                                       
}                                                                     
40009ff4:	81 c7 e0 08 	ret                                            
40009ff8:	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++ )               
40009ffc:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
    if ( !obj_info->local_table[i] )                                  
      unallocated++;                                                  
                                                                      
  info->unallocated = unallocated;                                    
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000a000:	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;                                    
4000a004:	10 bf ff fc 	b  40009ff4 <rtems_object_get_class_information+0x8c><== NOT EXECUTED
4000a008:	c4 26 a0 10 	st  %g2, [ %i2 + 0x10 ]                        <== NOT EXECUTED
                                                                      

400041b4 <rtems_panic>: void rtems_panic( const char *printf_format, ... ) {
400041b4:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  va_list arglist;                                                    
                                                                      
  va_start(arglist, printf_format);                                   
400041b8:	82 07 a0 48 	add  %fp, 0x48, %g1                            <== NOT EXECUTED
  (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);     
400041bc:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
400041c0:	94 10 00 01 	mov  %g1, %o2                                  <== NOT EXECUTED
  ...                                                                 
)                                                                     
{                                                                     
  va_list arglist;                                                    
                                                                      
  va_start(arglist, printf_format);                                   
400041c4:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          <== NOT EXECUTED
400041c8:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        <== NOT EXECUTED
400041cc:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        <== NOT EXECUTED
400041d0:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        <== NOT EXECUTED
400041d4:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        <== NOT EXECUTED
400041d8:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        <== NOT EXECUTED
  (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);     
400041dc:	7f ff ff 77 	call  40003fb8 <rtems_verror>                  <== NOT EXECUTED
400041e0:	11 08 00 00 	sethi  %hi(0x20000000), %o0                    <== NOT EXECUTED
  va_end(arglist);                                                    
                                                                      
  rtems_error(0, "fatal error, exiting");                             
400041e4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
400041e8:	13 10 00 76 	sethi  %hi(0x4001d800), %o1                    <== NOT EXECUTED
400041ec:	7f ff ff d0 	call  4000412c <rtems_error>                   <== NOT EXECUTED
400041f0:	92 12 62 68 	or  %o1, 0x268, %o1	! 4001da68 <IMFS_node_control_default+0xa0><== NOT EXECUTED
  _exit(errno);                                                       
400041f4:	40 00 31 d3 	call  40010940 <__errno>                       <== NOT EXECUTED
400041f8:	01 00 00 00 	nop                                            <== NOT EXECUTED
400041fc:	40 00 02 50 	call  40004b3c <_exit>                         <== NOT EXECUTED
40004200:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
                                                                      

40009a04 <rtems_partition_create>: uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) {
40009a04:	9d e3 bf a0 	save  %sp, -96, %sp                            
  register Partition_Control *the_partition;                          
                                                                      
  if ( !rtems_is_name_valid( name ) )                                 
40009a08:	80 a6 20 00 	cmp  %i0, 0                                    
40009a0c:	12 80 00 04 	bne  40009a1c <rtems_partition_create+0x18>    
40009a10:	82 10 20 03 	mov  3, %g1                                    
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40009a14:	81 c7 e0 08 	ret                                            
40009a18:	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 )                                            
40009a1c:	80 a6 60 00 	cmp  %i1, 0                                    
40009a20:	02 bf ff fd 	be  40009a14 <rtems_partition_create+0x10>     
40009a24:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !id )                                                          
40009a28:	80 a7 60 00 	cmp  %i5, 0                                    
40009a2c:	02 bf ff fa 	be  40009a14 <rtems_partition_create+0x10>     <== NEVER TAKEN
40009a30:	80 a6 e0 00 	cmp  %i3, 0                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( length == 0 || buffer_size == 0 || length < buffer_size ||     
40009a34:	02 bf ff f8 	be  40009a14 <rtems_partition_create+0x10>     
40009a38:	82 10 20 08 	mov  8, %g1                                    
40009a3c:	80 a6 a0 00 	cmp  %i2, 0                                    
40009a40:	02 bf ff f5 	be  40009a14 <rtems_partition_create+0x10>     
40009a44:	80 a6 80 1b 	cmp  %i2, %i3                                  
40009a48:	0a bf ff f3 	bcs  40009a14 <rtems_partition_create+0x10>    
40009a4c:	80 8e e0 07 	btst  7, %i3                                   
40009a50:	12 bf ff f1 	bne  40009a14 <rtems_partition_create+0x10>    
40009a54:	80 8e 60 07 	btst  7, %i1                                   
         !_Partition_Is_buffer_size_aligned( buffer_size ) )          
    return RTEMS_INVALID_SIZE;                                        
                                                                      
  if ( !_Addresses_Is_aligned( starting_address ) )                   
40009a58:	12 bf ff ef 	bne  40009a14 <rtems_partition_create+0x10>    
40009a5c:	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;                  
40009a60:	03 10 00 93 	sethi  %hi(0x40024c00), %g1                    
40009a64:	c4 00 60 b0 	ld  [ %g1 + 0xb0 ], %g2	! 40024cb0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
40009a68:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40009a6c:	c4 20 60 b0 	st  %g2, [ %g1 + 0xb0 ]                        
 *  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 );
40009a70:	23 10 00 92 	sethi  %hi(0x40024800), %l1                    
40009a74:	40 00 07 6f 	call  4000b830 <_Objects_Allocate>             
40009a78:	90 14 62 ac 	or  %l1, 0x2ac, %o0	! 40024aac <_Partition_Information>
                                                                      
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
40009a7c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40009a80:	02 80 00 1a 	be  40009ae8 <rtems_partition_create+0xe4>     
40009a84:	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;               
40009a88:	f8 24 20 1c 	st  %i4, [ %l0 + 0x1c ]                        
    _Thread_Enable_dispatch();                                        
    return RTEMS_TOO_MANY;                                            
  }                                                                   
#endif                                                                
                                                                      
  the_partition->starting_address      = starting_address;            
40009a8c:	f2 24 20 10 	st  %i1, [ %l0 + 0x10 ]                        
  the_partition->length                = length;                      
40009a90:	f4 24 20 14 	st  %i2, [ %l0 + 0x14 ]                        
  the_partition->buffer_size           = buffer_size;                 
40009a94:	f6 24 20 18 	st  %i3, [ %l0 + 0x18 ]                        
  the_partition->attribute_set         = attribute_set;               
  the_partition->number_of_used_blocks = 0;                           
40009a98:	c0 24 20 20 	clr  [ %l0 + 0x20 ]                            
                                                                      
  _Chain_Initialize( &the_partition->Memory, starting_address,        
                        length / buffer_size, buffer_size );          
40009a9c:	40 00 47 d1 	call  4001b9e0 <.udiv>                         
40009aa0:	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,        
40009aa4:	92 10 00 19 	mov  %i1, %o1                                  
                        length / buffer_size, buffer_size );          
40009aa8:	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,        
40009aac:	96 10 00 1b 	mov  %i3, %o3                                  
40009ab0:	b8 04 20 24 	add  %l0, 0x24, %i4                            
40009ab4:	40 00 04 a5 	call  4000ad48 <_Chain_Initialize>             
40009ab8:	90 10 00 1c 	mov  %i4, %o0                                  
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40009abc:	c4 14 20 0a 	lduh  [ %l0 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40009ac0:	a2 14 62 ac 	or  %l1, 0x2ac, %l1                            
40009ac4:	c6 04 60 1c 	ld  [ %l1 + 0x1c ], %g3                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  Objects_Name         name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40009ac8:	c2 04 20 08 	ld  [ %l0 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
40009acc:	85 28 a0 02 	sll  %g2, 2, %g2                               
40009ad0:	e0 20 c0 02 	st  %l0, [ %g3 + %g2 ]                         
    information,                                                      
    _Objects_Get_index( the_object->id ),                             
    the_object                                                        
  );                                                                  
                                                                      
  the_object->name = name;                                            
40009ad4:	f0 24 20 0c 	st  %i0, [ %l0 + 0xc ]                         
      name,                                                           
      0                  /* Not used */                               
    );                                                                
#endif                                                                
                                                                      
  _Thread_Enable_dispatch();                                          
40009ad8:	40 00 0c a2 	call  4000cd60 <_Thread_Enable_dispatch>       
40009adc:	c2 27 40 00 	st  %g1, [ %i5 ]                               
  return RTEMS_SUCCESSFUL;                                            
40009ae0:	10 bf ff cd 	b  40009a14 <rtems_partition_create+0x10>      
40009ae4:	82 10 20 00 	clr  %g1                                       
  _Thread_Disable_dispatch();               /* prevents deletion */   
                                                                      
  the_partition = _Partition_Allocate();                              
                                                                      
  if ( !the_partition ) {                                             
    _Thread_Enable_dispatch();                                        
40009ae8:	40 00 0c 9e 	call  4000cd60 <_Thread_Enable_dispatch>       
40009aec:	01 00 00 00 	nop                                            
    return RTEMS_TOO_MANY;                                            
40009af0:	10 bf ff c9 	b  40009a14 <rtems_partition_create+0x10>      
40009af4:	82 10 20 05 	mov  5, %g1	! 5 <PROM_START+0x5>               
                                                                      

400161dc <rtems_partition_return_buffer>: rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) {
400161dc:	9d e3 bf 98 	save  %sp, -104, %sp                           
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (              
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Partition_Control *)                                        
400161e0:	11 10 00 f9 	sethi  %hi(0x4003e400), %o0                    
400161e4:	92 10 00 18 	mov  %i0, %o1                                  
400161e8:	90 12 22 5c 	or  %o0, 0x25c, %o0                            
400161ec:	40 00 15 26 	call  4001b684 <_Objects_Get>                  
400161f0:	94 07 bf fc 	add  %fp, -4, %o2                              
  register Partition_Control *the_partition;                          
  Objects_Locations           location;                               
                                                                      
  the_partition = _Partition_Get( id, &location );                    
  switch ( location ) {                                               
400161f4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400161f8:	80 a0 60 00 	cmp  %g1, 0                                    
400161fc:	12 80 00 19 	bne  40016260 <rtems_partition_return_buffer+0x84>
40016200:	ba 10 00 08 	mov  %o0, %i5                                  
)                                                                     
{                                                                     
  void *starting;                                                     
  void *ending;                                                       
                                                                      
  starting = the_partition->starting_address;                         
40016204:	d0 02 20 10 	ld  [ %o0 + 0x10 ], %o0                        
40016208:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4001620c:	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 ) &&         
40016210:	80 a6 40 01 	cmp  %i1, %g1                                  
40016214:	18 80 00 15 	bgu  40016268 <rtems_partition_return_buffer+0x8c><== NEVER TAKEN
40016218:	80 a6 40 08 	cmp  %i1, %o0                                  
4001621c:	0a 80 00 13 	bcs  40016268 <rtems_partition_return_buffer+0x8c>
40016220:	01 00 00 00 	nop                                            
  offset = (uint32_t) _Addresses_Subtract(                            
    the_buffer,                                                       
    the_partition->starting_address                                   
  );                                                                  
                                                                      
  return ((offset % the_partition->buffer_size) == 0);                
40016224:	d2 07 60 18 	ld  [ %i5 + 0x18 ], %o1                        
40016228:	40 00 5a e1 	call  4002cdac <.urem>                         
4001622c:	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 ) &&         
40016230:	80 a2 20 00 	cmp  %o0, 0                                    
40016234:	12 80 00 0d 	bne  40016268 <rtems_partition_return_buffer+0x8c>
40016238:	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 );                
4001623c:	40 00 0d 11 	call  40019680 <_Chain_Append>                 
40016240:	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;                    
40016244:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
40016248:	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;                    
4001624c:	82 00 7f ff 	add  %g1, -1, %g1                              
        _Thread_Enable_dispatch();                                    
40016250:	40 00 18 f0 	call  4001c610 <_Thread_Enable_dispatch>       
40016254:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
40016258:	81 c7 e0 08 	ret                                            
4001625c:	81 e8 00 00 	restore                                        
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
40016260:	81 c7 e0 08 	ret                                            
40016264:	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();                                      
40016268:	40 00 18 ea 	call  4001c610 <_Thread_Enable_dispatch>       
4001626c:	b0 10 20 09 	mov  9, %i0                                    
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40016270:	81 c7 e0 08 	ret                                            
40016274:	81 e8 00 00 	restore                                        
                                                                      

40038b00 <rtems_rate_monotonic_period>: rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) {
40038b00:	9d e3 bf 98 	save  %sp, -104, %sp                           
40038b04:	11 10 01 a8 	sethi  %hi(0x4006a000), %o0                    
40038b08:	92 10 00 18 	mov  %i0, %o1                                  
40038b0c:	90 12 23 68 	or  %o0, 0x368, %o0                            
40038b10:	7f ff 44 18 	call  40009b70 <_Objects_Get>                  
40038b14:	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 ) {                                               
40038b18:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40038b1c:	80 a0 60 00 	cmp  %g1, 0                                    
40038b20:	12 80 00 0d 	bne  40038b54 <rtems_rate_monotonic_period+0x54>
40038b24:	ba 10 00 08 	mov  %o0, %i5                                  
    case OBJECTS_LOCAL:                                               
      if ( !_Thread_Is_executing( the_period->owner ) ) {             
40038b28:	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 );                         
40038b2c:	39 10 01 a7 	sethi  %hi(0x40069c00), %i4                    
40038b30:	b8 17 21 a0 	or  %i4, 0x1a0, %i4	! 40069da0 <_Per_CPU_Information>
40038b34:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
40038b38:	80 a0 80 01 	cmp  %g2, %g1                                  
40038b3c:	02 80 00 08 	be  40038b5c <rtems_rate_monotonic_period+0x5c>
40038b40:	80 a6 60 00 	cmp  %i1, 0                                    
        _Thread_Enable_dispatch();                                    
40038b44:	7f ff 47 c2 	call  4000aa4c <_Thread_Enable_dispatch>       
40038b48:	b0 10 20 17 	mov  0x17, %i0                                 
40038b4c:	81 c7 e0 08 	ret                                            
40038b50:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40038b54:	81 c7 e0 08 	ret                                            
40038b58:	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 ) {                          
40038b5c:	12 80 00 0e 	bne  40038b94 <rtems_rate_monotonic_period+0x94>
40038b60:	01 00 00 00 	nop                                            
        switch ( the_period->state ) {                                
40038b64:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
40038b68:	80 a0 60 04 	cmp  %g1, 4                                    
40038b6c:	18 80 00 06 	bgu  40038b84 <rtems_rate_monotonic_period+0x84><== NEVER TAKEN
40038b70:	b0 10 20 00 	clr  %i0                                       
40038b74:	83 28 60 02 	sll  %g1, 2, %g1                               
40038b78:	05 10 01 8d 	sethi  %hi(0x40063400), %g2                    
40038b7c:	84 10 a1 50 	or  %g2, 0x150, %g2	! 40063550 <CSWTCH.24>     
40038b80:	f0 00 80 01 	ld  [ %g2 + %g1 ], %i0                         
          id,                                                         
          NULL                                                        
        );                                                            
                                                                      
        _Watchdog_Insert_ticks( &the_period->Timer, length );         
        _Thread_Enable_dispatch();                                    
40038b84:	7f ff 47 b2 	call  4000aa4c <_Thread_Enable_dispatch>       
40038b88:	01 00 00 00 	nop                                            
40038b8c:	81 c7 e0 08 	ret                                            
40038b90:	81 e8 00 00 	restore                                        
        }                                                             
        _Thread_Enable_dispatch();                                    
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
40038b94:	7f ff 25 c3 	call  400022a0 <sparc_disable_interrupts>      
40038b98:	01 00 00 00 	nop                                            
40038b9c:	b4 10 00 08 	mov  %o0, %i2                                  
      if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {           
40038ba0:	f6 07 60 38 	ld  [ %i5 + 0x38 ], %i3                        
40038ba4:	80 a6 e0 00 	cmp  %i3, 0                                    
40038ba8:	02 80 00 1c 	be  40038c18 <rtems_rate_monotonic_period+0x118>
40038bac:	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 ) {             
40038bb0:	02 80 00 2e 	be  40038c68 <rtems_rate_monotonic_period+0x168>
40038bb4:	80 a6 e0 04 	cmp  %i3, 4                                    
                                                                      
        _Thread_Enable_dispatch();                                    
        return RTEMS_SUCCESSFUL;                                      
      }                                                               
                                                                      
      if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {            
40038bb8:	12 bf ff e5 	bne  40038b4c <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
40038bbc:	b0 10 20 04 	mov  4, %i0                                    
        /*                                                            
         *  Update statistics from the concluding period              
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
40038bc0:	7f ff ff 5e 	call  40038938 <_Rate_monotonic_Update_statistics>
40038bc4:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
        _ISR_Enable( level );                                         
40038bc8:	7f ff 25 ba 	call  400022b0 <sparc_enable_interrupts>       
40038bcc:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
40038bd0:	82 10 20 02 	mov  2, %g1                                    
40038bd4:	92 07 60 10 	add  %i5, 0x10, %o1                            
40038bd8:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
        the_period->next_length = length;                             
40038bdc:	f2 27 60 3c 	st  %i1, [ %i5 + 0x3c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40038be0:	f2 27 60 1c 	st  %i1, [ %i5 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40038be4:	11 10 01 a6 	sethi  %hi(0x40069800), %o0                    
40038be8:	7f ff 4a d5 	call  4000b73c <_Watchdog_Insert>              
40038bec:	90 12 21 28 	or  %o0, 0x128, %o0	! 40069928 <_Watchdog_Ticks_chain>
40038bf0:	d0 07 60 40 	ld  [ %i5 + 0x40 ], %o0                        
40038bf4:	d2 07 60 3c 	ld  [ %i5 + 0x3c ], %o1                        
40038bf8:	03 10 01 95 	sethi  %hi(0x40065400), %g1                    
40038bfc:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1	! 40065414 <_Scheduler+0x34>
40038c00:	9f c0 40 00 	call  %g1                                      
40038c04:	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();                                    
40038c08:	7f ff 47 91 	call  4000aa4c <_Thread_Enable_dispatch>       
40038c0c:	01 00 00 00 	nop                                            
40038c10:	81 c7 e0 08 	ret                                            
40038c14:	81 e8 00 00 	restore                                        
        return( return_value );                                       
      }                                                               
                                                                      
      _ISR_Disable( level );                                          
      if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {           
        _ISR_Enable( level );                                         
40038c18:	7f ff 25 a6 	call  400022b0 <sparc_enable_interrupts>       
40038c1c:	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 );            
40038c20:	90 10 00 1d 	mov  %i5, %o0                                  
40038c24:	7f ff ff 94 	call  40038a74 <_Rate_monotonic_Initiate_statistics>
40038c28:	f2 27 60 3c 	st  %i1, [ %i5 + 0x3c ]                        
                                                                      
        the_period->state = RATE_MONOTONIC_ACTIVE;                    
40038c2c:	82 10 20 02 	mov  2, %g1                                    
40038c30:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40038c34:	03 10 00 e3 	sethi  %hi(0x40038c00), %g1                    
40038c38:	82 10 60 dc 	or  %g1, 0xdc, %g1	! 40038cdc <_Rate_monotonic_Timeout>
  the_watchdog->id        = id;                                       
40038c3c:	f0 27 60 30 	st  %i0, [ %i5 + 0x30 ]                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40038c40:	92 07 60 10 	add  %i5, 0x10, %o1                            
40038c44:	11 10 01 a6 	sethi  %hi(0x40069800), %o0                    
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40038c48:	c0 27 60 18 	clr  [ %i5 + 0x18 ]                            
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40038c4c:	90 12 21 28 	or  %o0, 0x128, %o0                            
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
40038c50:	c0 27 60 34 	clr  [ %i5 + 0x34 ]                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40038c54:	c2 27 60 2c 	st  %g1, [ %i5 + 0x2c ]                        
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40038c58:	f2 27 60 1c 	st  %i1, [ %i5 + 0x1c ]                        
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40038c5c:	7f ff 4a b8 	call  4000b73c <_Watchdog_Insert>              
40038c60:	b0 10 20 00 	clr  %i0                                       
40038c64:	30 bf ff c8 	b,a   40038b84 <rtems_rate_monotonic_period+0x84>
                                                                      
      if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {             
        /*                                                            
         *  Update statistics from the concluding period.             
         */                                                           
        _Rate_monotonic_Update_statistics( the_period );              
40038c68:	7f ff ff 34 	call  40038938 <_Rate_monotonic_Update_statistics>
40038c6c:	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;         
40038c70:	82 10 20 01 	mov  1, %g1                                    
        the_period->next_length = length;                             
40038c74:	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;         
40038c78:	c2 27 60 38 	st  %g1, [ %i5 + 0x38 ]                        
        the_period->next_length = length;                             
                                                                      
        _ISR_Enable( level );                                         
40038c7c:	7f ff 25 8d 	call  400022b0 <sparc_enable_interrupts>       
40038c80:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
        _Thread_Executing->Wait.id = the_period->Object.id;           
40038c84:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
40038c88:	c4 07 60 08 	ld  [ %i5 + 8 ], %g2                           
        _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40038c8c:	90 10 00 01 	mov  %g1, %o0                                  
40038c90:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
40038c94:	7f ff 49 be 	call  4000b38c <_Thread_Set_state>             
40038c98:	c4 20 60 20 	st  %g2, [ %g1 + 0x20 ]                        
                                                                      
        /*                                                            
         *  Did the watchdog timer expire while we were actually blocking
         *  on it?                                                    
         */                                                           
        _ISR_Disable( level );                                        
40038c9c:	7f ff 25 81 	call  400022a0 <sparc_disable_interrupts>      
40038ca0:	01 00 00 00 	nop                                            
          local_state = the_period->state;                            
40038ca4:	f4 07 60 38 	ld  [ %i5 + 0x38 ], %i2                        
          the_period->state = RATE_MONOTONIC_ACTIVE;                  
40038ca8:	f6 27 60 38 	st  %i3, [ %i5 + 0x38 ]                        
        _ISR_Enable( level );                                         
40038cac:	7f ff 25 81 	call  400022b0 <sparc_enable_interrupts>       
40038cb0:	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 )   
40038cb4:	80 a6 a0 03 	cmp  %i2, 3                                    
40038cb8:	22 80 00 06 	be,a   40038cd0 <rtems_rate_monotonic_period+0x1d0>
40038cbc:	d0 07 20 10 	ld  [ %i4 + 0x10 ], %o0                        
          _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
                                                                      
        _Thread_Enable_dispatch();                                    
40038cc0:	7f ff 47 63 	call  4000aa4c <_Thread_Enable_dispatch>       
40038cc4:	b0 10 20 00 	clr  %i0                                       
40038cc8:	81 c7 e0 08 	ret                                            
40038ccc:	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 );
40038cd0:	7f ff 46 72 	call  4000a698 <_Thread_Clear_state>           
40038cd4:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
40038cd8:	30 bf ff fa 	b,a   40038cc0 <rtems_rate_monotonic_period+0x1c0>
                                                                      

4002a580 <rtems_rate_monotonic_report_statistics_with_plugin>: void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) {
4002a580:	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 )                                                       
4002a584:	80 a6 60 00 	cmp  %i1, 0                                    
4002a588:	02 80 00 48 	be  4002a6a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
4002a58c:	90 10 00 18 	mov  %i0, %o0                                  
    return;                                                           
                                                                      
  (*print)( context, "Period information by period\n" );              
4002a590:	13 10 01 82 	sethi  %hi(0x40060800), %o1                    
4002a594:	9f c6 40 00 	call  %i1                                      
4002a598:	92 12 60 28 	or  %o1, 0x28, %o1	! 40060828 <_TOD_Days_per_month+0x68>
  #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                          
    (*print)( context, "--- CPU times are in seconds ---\n" );        
4002a59c:	90 10 00 18 	mov  %i0, %o0                                  
4002a5a0:	13 10 01 82 	sethi  %hi(0x40060800), %o1                    
4002a5a4:	9f c6 40 00 	call  %i1                                      
4002a5a8:	92 12 60 48 	or  %o1, 0x48, %o1	! 40060848 <_TOD_Days_per_month+0x88>
    (*print)( context, "--- Wall times are in seconds ---\n" );       
4002a5ac:	90 10 00 18 	mov  %i0, %o0                                  
4002a5b0:	13 10 01 82 	sethi  %hi(0x40060800), %o1                    
4002a5b4:	9f c6 40 00 	call  %i1                                      
4002a5b8:	92 12 60 70 	or  %o1, 0x70, %o1	! 40060870 <_TOD_Days_per_month+0xb0>
  Be sure to test the various cases.                                  
  (*print)( context,"\                                                
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");                                                                 
*/                                                                    
  (*print)( context, "   ID     OWNER COUNT MISSED     "              
4002a5bc:	90 10 00 18 	mov  %i0, %o0                                  
4002a5c0:	13 10 01 82 	sethi  %hi(0x40060800), %o1                    
4002a5c4:	9f c6 40 00 	call  %i1                                      
4002a5c8:	92 12 60 98 	or  %o1, 0x98, %o1	! 40060898 <_TOD_Days_per_month+0xd8>
       #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__                     
          "          "                                                
       #endif                                                         
          "   WALL TIME\n"                                            
  );                                                                  
  (*print)( context, "                               "                
4002a5cc:	90 10 00 18 	mov  %i0, %o0                                  
4002a5d0:	13 10 01 82 	sethi  %hi(0x40060800), %o1                    
4002a5d4:	9f c6 40 00 	call  %i1                                      
4002a5d8:	92 12 60 e8 	or  %o1, 0xe8, %o1	! 400608e8 <_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 ;                   
4002a5dc:	39 10 01 a8 	sethi  %hi(0x4006a000), %i4                    
4002a5e0:	b8 17 23 68 	or  %i4, 0x368, %i4	! 4006a368 <_Rate_monotonic_Information>
4002a5e4:	fa 07 20 08 	ld  [ %i4 + 8 ], %i5                           
4002a5e8:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
4002a5ec:	80 a7 40 01 	cmp  %i5, %g1                                  
4002a5f0:	18 80 00 2e 	bgu  4002a6a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128><== NEVER TAKEN
4002a5f4:	35 10 01 82 	sethi  %hi(0x40060800), %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,                                              
4002a5f8:	27 10 01 82 	sethi  %hi(0x40060800), %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,                                              
4002a5fc:	25 10 01 82 	sethi  %hi(0x40060800), %l2                    
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
      (*print)( context, "\n" );                                      
4002a600:	37 10 01 87 	sethi  %hi(0x40061c00), %i3                    
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
4002a604:	b4 16 a1 38 	or  %i2, 0x138, %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,                                              
4002a608:	a6 14 e1 50 	or  %l3, 0x150, %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,                                              
4002a60c:	a4 14 a1 70 	or  %l2, 0x170, %l2                            
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
      (*print)( context, "\n" );                                      
4002a610:	10 80 00 06 	b  4002a628 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8>
4002a614:	b6 16 e2 00 	or  %i3, 0x200, %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++ ) {                                                      
4002a618:	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 ;                   
4002a61c:	80 a0 40 1d 	cmp  %g1, %i5                                  
4002a620:	0a 80 00 22 	bcs  4002a6a8 <rtems_rate_monotonic_report_statistics_with_plugin+0x128>
4002a624:	01 00 00 00 	nop                                            
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );   
4002a628:	90 10 00 1d 	mov  %i5, %o0                                  
4002a62c:	40 00 37 df 	call  400385a8 <rtems_rate_monotonic_get_statistics>
4002a630:	92 07 bf c8 	add  %fp, -56, %o1                             
    if ( status != RTEMS_SUCCESSFUL )                                 
4002a634:	80 a2 20 00 	cmp  %o0, 0                                    
4002a638:	32 bf ff f8 	bne,a   4002a618 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
4002a63c:	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 );      
4002a640:	92 07 bf b0 	add  %fp, -80, %o1                             
4002a644:	40 00 38 4b 	call  40038770 <rtems_rate_monotonic_get_status>
4002a648:	90 10 00 1d 	mov  %i5, %o0                                  
    #endif                                                            
                                                                      
    rtems_object_get_name( the_status.owner, sizeof(name), name );    
4002a64c:	d0 07 bf b0 	ld  [ %fp + -80 ], %o0                         
4002a650:	94 07 bf a0 	add  %fp, -96, %o2                             
4002a654:	7f ff 97 9e 	call  400104cc <rtems_object_get_name>         
4002a658:	92 10 20 05 	mov  5, %o1                                    
                                                                      
    /*                                                                
     *  Print part of report line that is not dependent on granularity
     */                                                               
    (*print)( context,                                                
4002a65c:	d8 1f bf c8 	ldd  [ %fp + -56 ], %o4                        
4002a660:	92 10 00 1a 	mov  %i2, %o1                                  
4002a664:	94 10 00 1d 	mov  %i5, %o2                                  
4002a668:	90 10 00 18 	mov  %i0, %o0                                  
4002a66c:	9f c6 40 00 	call  %i1                                      
4002a670:	96 07 bf a0 	add  %fp, -96, %o3                             
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
4002a674:	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 );
4002a678:	94 07 bf a8 	add  %fp, -88, %o2                             
4002a67c:	90 07 bf e0 	add  %fp, -32, %o0                             
    );                                                                
                                                                      
    /*                                                                
     *  If the count is zero, don't print statistics                  
     */                                                               
    if (the_stats.count == 0) {                                       
4002a680:	80 a0 60 00 	cmp  %g1, 0                                    
4002a684:	12 80 00 0b 	bne  4002a6b0 <rtems_rate_monotonic_report_statistics_with_plugin+0x130>
4002a688:	92 10 00 1b 	mov  %i3, %o1                                  
      (*print)( context, "\n" );                                      
4002a68c:	9f c6 40 00 	call  %i1                                      
4002a690:	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 ;                   
4002a694:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
        id <= _Rate_monotonic_Information.maximum_id ;                
        id++ ) {                                                      
4002a698:	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 ;                   
4002a69c:	80 a0 40 1d 	cmp  %g1, %i5                                  
4002a6a0:	1a bf ff e3 	bcc  4002a62c <rtems_rate_monotonic_report_statistics_with_plugin+0xac><== ALWAYS TAKEN
4002a6a4:	90 10 00 1d 	mov  %i5, %o0                                  
4002a6a8:	81 c7 e0 08 	ret                                            
4002a6ac:	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 );
4002a6b0:	40 00 03 5e 	call  4002b428 <_Timespec_Divide_by_integer>   
4002a6b4:	92 10 00 01 	mov  %g1, %o1                                  
      (*print)( context,                                              
4002a6b8:	d0 07 bf d4 	ld  [ %fp + -44 ], %o0                         
4002a6bc:	40 00 ae e2 	call  40056244 <.div>                          
4002a6c0:	92 10 23 e8 	mov  0x3e8, %o1                                
4002a6c4:	aa 10 00 08 	mov  %o0, %l5                                  
4002a6c8:	d0 07 bf dc 	ld  [ %fp + -36 ], %o0                         
4002a6cc:	40 00 ae de 	call  40056244 <.div>                          
4002a6d0:	92 10 23 e8 	mov  0x3e8, %o1                                
4002a6d4:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
4002a6d8:	a2 10 00 08 	mov  %o0, %l1                                  
4002a6dc:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
4002a6e0:	e0 07 bf d0 	ld  [ %fp + -48 ], %l0                         
4002a6e4:	e8 07 bf d8 	ld  [ %fp + -40 ], %l4                         
4002a6e8:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
4002a6ec:	40 00 ae d6 	call  40056244 <.div>                          
4002a6f0:	92 10 23 e8 	mov  0x3e8, %o1                                
4002a6f4:	96 10 00 15 	mov  %l5, %o3                                  
4002a6f8:	98 10 00 14 	mov  %l4, %o4                                  
4002a6fc:	9a 10 00 11 	mov  %l1, %o5                                  
4002a700:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
4002a704:	92 10 00 13 	mov  %l3, %o1                                  
4002a708:	94 10 00 10 	mov  %l0, %o2                                  
4002a70c:	9f c6 40 00 	call  %i1                                      
4002a710:	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);
4002a714:	d2 07 bf c8 	ld  [ %fp + -56 ], %o1                         
4002a718:	94 07 bf a8 	add  %fp, -88, %o2                             
4002a71c:	40 00 03 43 	call  4002b428 <_Timespec_Divide_by_integer>   
4002a720:	90 07 bf f8 	add  %fp, -8, %o0                              
      (*print)( context,                                              
4002a724:	d0 07 bf ec 	ld  [ %fp + -20 ], %o0                         
4002a728:	40 00 ae c7 	call  40056244 <.div>                          
4002a72c:	92 10 23 e8 	mov  0x3e8, %o1                                
4002a730:	a8 10 00 08 	mov  %o0, %l4                                  
4002a734:	d0 07 bf f4 	ld  [ %fp + -12 ], %o0                         
4002a738:	40 00 ae c3 	call  40056244 <.div>                          
4002a73c:	92 10 23 e8 	mov  0x3e8, %o1                                
4002a740:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
4002a744:	a0 10 00 08 	mov  %o0, %l0                                  
4002a748:	d0 07 bf ac 	ld  [ %fp + -84 ], %o0                         
4002a74c:	ea 07 bf e8 	ld  [ %fp + -24 ], %l5                         
4002a750:	e2 07 bf f0 	ld  [ %fp + -16 ], %l1                         
4002a754:	92 10 23 e8 	mov  0x3e8, %o1                                
4002a758:	40 00 ae bb 	call  40056244 <.div>                          
4002a75c:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
4002a760:	92 10 00 12 	mov  %l2, %o1                                  
4002a764:	d0 23 a0 60 	st  %o0, [ %sp + 0x60 ]                        
4002a768:	94 10 00 15 	mov  %l5, %o2                                  
4002a76c:	90 10 00 18 	mov  %i0, %o0                                  
4002a770:	96 10 00 14 	mov  %l4, %o3                                  
4002a774:	98 10 00 11 	mov  %l1, %o4                                  
4002a778:	9f c6 40 00 	call  %i1                                      
4002a77c:	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 ;                   
4002a780:	10 bf ff a6 	b  4002a618 <rtems_rate_monotonic_report_statistics_with_plugin+0x98>
4002a784:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
                                                                      

4002a7a0 <rtems_rate_monotonic_reset_all_statistics>: /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) {
4002a7a0:	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;                  
4002a7a4:	03 10 01 a6 	sethi  %hi(0x40069800), %g1                    
4002a7a8:	c4 00 60 90 	ld  [ %g1 + 0x90 ], %g2	! 40069890 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
4002a7ac:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
4002a7b0:	c4 20 60 90 	st  %g2, [ %g1 + 0x90 ]                        
                                                                      
    /*                                                                
     * 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 ;                 
4002a7b4:	39 10 01 a8 	sethi  %hi(0x4006a000), %i4                    
4002a7b8:	b8 17 23 68 	or  %i4, 0x368, %i4	! 4006a368 <_Rate_monotonic_Information>
4002a7bc:	fa 07 20 08 	ld  [ %i4 + 8 ], %i5                           
4002a7c0:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
4002a7c4:	80 a7 40 01 	cmp  %i5, %g1                                  
4002a7c8:	18 80 00 09 	bgu  4002a7ec <rtems_rate_monotonic_reset_all_statistics+0x4c><== NEVER TAKEN
4002a7cc:	01 00 00 00 	nop                                            
          id <= _Rate_monotonic_Information.maximum_id ;              
          id++ ) {                                                    
      (void) rtems_rate_monotonic_reset_statistics( id );             
4002a7d0:	40 00 00 09 	call  4002a7f4 <rtems_rate_monotonic_reset_statistics>
4002a7d4:	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 ;                 
4002a7d8:	c2 07 20 0c 	ld  [ %i4 + 0xc ], %g1                         
          id <= _Rate_monotonic_Information.maximum_id ;              
          id++ ) {                                                    
4002a7dc:	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 ;                 
4002a7e0:	80 a0 40 1d 	cmp  %g1, %i5                                  
4002a7e4:	1a bf ff fb 	bcc  4002a7d0 <rtems_rate_monotonic_reset_all_statistics+0x30>
4002a7e8:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
  /*                                                                  
   *  Done so exit thread dispatching disabled critical section.      
   */                                                                 
  _Thread_Enable_dispatch();                                          
4002a7ec:	7f ff 80 98 	call  4000aa4c <_Thread_Enable_dispatch>       
4002a7f0:	81 e8 00 00 	restore                                        
                                                                      

400094f4 <rtems_rbheap_allocate>: return big_enough; } void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size) {
400094f4:	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;                           
400094f8:	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;                               
400094fc:	90 10 00 19 	mov  %i1, %o0                                  
40009500:	40 00 2f 87 	call  4001531c <.urem>                         
40009504:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
  if (excess > 0) {                                                   
40009508:	80 a2 20 00 	cmp  %o0, 0                                    
4000950c:	02 80 00 26 	be  400095a4 <rtems_rbheap_allocate+0xb0>      <== ALWAYS TAKEN
40009510:	b6 10 00 19 	mov  %i1, %i3                                  
    value += alignment - excess;                                      
40009514:	ba 06 40 1d 	add  %i1, %i5, %i5                             <== NOT EXECUTED
40009518:	b6 27 40 08 	sub  %i5, %o0, %i3                             <== NOT EXECUTED
4000951c:	80 a6 c0 19 	cmp  %i3, %i1                                  <== NOT EXECUTED
40009520:	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) {                             
40009524:	80 88 60 ff 	btst  0xff, %g1                                
40009528:	02 80 00 1d 	be  4000959c <rtems_rbheap_allocate+0xa8>      <== NEVER TAKEN
4000952c:	80 a6 60 00 	cmp  %i1, 0                                    
40009530:	02 80 00 1b 	be  4000959c <rtems_rbheap_allocate+0xa8>      
40009534:	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;                              
40009538:	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) {                     
4000953c:	80 a7 40 01 	cmp  %i5, %g1                                  
40009540:	02 80 00 17 	be  4000959c <rtems_rbheap_allocate+0xa8>      
40009544:	01 00 00 00 	nop                                            
    rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;  
                                                                      
    if (free_chunk->size >= size) {                                   
40009548:	f8 07 60 1c 	ld  [ %i5 + 0x1c ], %i4                        
4000954c:	80 a6 c0 1c 	cmp  %i3, %i4                                  
40009550:	38 80 00 10 	bgu,a   40009590 <rtems_rbheap_allocate+0x9c>  
40009554:	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) {                                         
40009558:	80 a7 60 00 	cmp  %i5, 0                                    
4000955c:	02 80 00 10 	be  4000959c <rtems_rbheap_allocate+0xa8>      <== NEVER TAKEN
40009560:	80 a7 00 1b 	cmp  %i4, %i3                                  
      uintptr_t free_size = free_chunk->size;                         
                                                                      
      if (free_size > aligned_size) {                                 
40009564:	18 80 00 12 	bgu  400095ac <rtems_rbheap_allocate+0xb8>     
40009568:	01 00 00 00 	nop                                            
)                                                                     
{                                                                     
  Chain_Node *next;                                                   
  Chain_Node *previous;                                               
                                                                      
  next           = the_node->next;                                    
4000956c:	c4 07 40 00 	ld  [ %i5 ], %g2                               
  previous       = the_node->previous;                                
40009570:	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;                             
40009574:	f0 07 60 18 	ld  [ %i5 + 0x18 ], %i0                        
  next->previous = previous;                                          
40009578:	c2 20 a0 04 	st  %g1, [ %g2 + 4 ]                           
  previous->next = next;                                              
4000957c:	c4 20 40 00 	st  %g2, [ %g1 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
40009580:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
40009584:	c0 27 40 00 	clr  [ %i5 ]                                   
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return ptr;                                                         
}                                                                     
40009588:	81 c7 e0 08 	ret                                            
4000958c:	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) {                     
40009590:	80 a0 40 1d 	cmp  %g1, %i5                                  
40009594:	32 bf ff ee 	bne,a   4000954c <rtems_rbheap_allocate+0x58>  <== NEVER TAKEN
40009598:	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;                                                   
4000959c:	81 c7 e0 08 	ret                                            
400095a0:	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) {                                                   
400095a4:	10 bf ff e0 	b  40009524 <rtems_rbheap_allocate+0x30>       
400095a8:	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);           
400095ac:	7f ff ff 46 	call  400092c4 <get_chunk>                     
400095b0:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
        if (new_chunk != NULL) {                                      
400095b4:	b4 92 20 00 	orcc  %o0, 0, %i2                              
400095b8:	02 bf ff f9 	be  4000959c <rtems_rbheap_allocate+0xa8>      <== NEVER TAKEN
400095bc:	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;       
400095c0:	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;                           
400095c4:	f8 27 60 1c 	st  %i4, [ %i5 + 0x1c ]                        
          new_chunk->begin = free_chunk->begin + new_free_size;       
          new_chunk->size = aligned_size;                             
400095c8:	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;       
400095cc:	b8 07 00 01 	add  %i4, %g1, %i4                             
400095d0:	c0 26 a0 04 	clr  [ %i2 + 4 ]                               
400095d4:	f8 26 a0 18 	st  %i4, [ %i2 + 0x18 ]                        
400095d8:	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);                
400095dc:	90 06 20 18 	add  %i0, 0x18, %o0                            
400095e0:	40 00 06 fd 	call  4000b1d4 <_RBTree_Insert_unprotected>    
400095e4:	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;                            
400095e8:	f0 06 a0 18 	ld  [ %i2 + 0x18 ], %i0                        
400095ec:	81 c7 e0 08 	ret                                            
400095f0:	81 e8 00 00 	restore                                        
                                                                      

40009738 <rtems_rbheap_extend_descriptors_with_malloc>: /* Do nothing */ } void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control) {
40009738:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));                 
4000973c:	7f ff ec d6 	call  40004a94 <malloc>                        <== NOT EXECUTED
40009740:	90 10 20 20 	mov  0x20, %o0                                 <== NOT EXECUTED
                                                                      
  if (chunk != NULL) {                                                
40009744:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40009748:	02 80 00 07 	be  40009764 <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
4000974c:	84 06 20 0c 	add  %i0, 0xc, %g2                             <== NOT EXECUTED
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
40009750:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         <== NOT EXECUTED
  after_node->next      = the_node;                                   
40009754:	d0 26 20 0c 	st  %o0, [ %i0 + 0xc ]                         <== NOT EXECUTED
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
40009758:	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;                                
4000975c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  before_node->previous = the_node;                                   
40009760:	d0 20 60 04 	st  %o0, [ %g1 + 4 ]                           <== NOT EXECUTED
40009764:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40009768:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400095f4 <rtems_rbheap_free>: _RBTree_Extract_unprotected(chunk_tree, &b->tree_node); } } rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr) {
400095f4:	9d e3 bf 80 	save  %sp, -128, %sp                           
400095f8:	b4 10 00 18 	mov  %i0, %i2                                  
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (ptr != NULL) {                                                  
400095fc:	80 a6 60 00 	cmp  %i1, 0                                    
40009600:	02 80 00 2a 	be  400096a8 <rtems_rbheap_free+0xb4>          
40009604:	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;                          
40009608:	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 };                        
4000960c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
40009610:	c0 27 bf e0 	clr  [ %fp + -32 ]                             
40009614:	c0 27 bf e4 	clr  [ %fp + -28 ]                             
40009618:	c0 27 bf e8 	clr  [ %fp + -24 ]                             
4000961c:	c0 27 bf ec 	clr  [ %fp + -20 ]                             
40009620:	c0 27 bf f0 	clr  [ %fp + -16 ]                             
40009624:	c0 27 bf f4 	clr  [ %fp + -12 ]                             
40009628:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
  RBTree_Node* found = NULL;                                          
  int compare_result;                                                 
  while (iter_node) {                                                 
4000962c:	80 a7 60 00 	cmp  %i5, 0                                    
40009630:	02 80 00 3e 	be  40009728 <rtems_rbheap_free+0x134>         <== NEVER TAKEN
40009634:	b8 06 a0 18 	add  %i2, 0x18, %i4                            
40009638:	b6 10 20 00 	clr  %i3                                       
    compare_result = the_rbtree->compare_function(the_node, iter_node);
4000963c:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
40009640:	92 10 00 1d 	mov  %i5, %o1                                  
40009644:	9f c0 40 00 	call  %g1                                      
40009648:	90 07 bf e8 	add  %fp, -24, %o0                             
                                                                      
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(                         
  int compare_result                                                  
)                                                                     
{                                                                     
  return compare_result > 0;                                          
4000964c:	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 ) ) {                       
40009650:	80 a2 20 00 	cmp  %o0, 0                                    
                                                                      
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(                         
  int compare_result                                                  
)                                                                     
{                                                                     
  return compare_result > 0;                                          
40009654:	82 20 40 08 	sub  %g1, %o0, %g1                             
40009658:	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];                                
4000965c:	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 ) ) {                       
40009660:	12 80 00 06 	bne  40009678 <rtems_rbheap_free+0x84>         
40009664:	82 07 40 01 	add  %i5, %g1, %g1                             
      found = iter_node;                                              
      if ( the_rbtree->is_unique )                                    
40009668:	c4 0f 20 14 	ldub  [ %i4 + 0x14 ], %g2                      
4000966c:	80 a0 a0 00 	cmp  %g2, 0                                    
40009670:	12 80 00 10 	bne  400096b0 <rtems_rbheap_free+0xbc>         <== ALWAYS TAKEN
40009674:	b6 10 00 1d 	mov  %i5, %i3                                  
        break;                                                        
    }                                                                 
                                                                      
    RBTree_Direction dir =                                            
      (RBTree_Direction) _RBTree_Is_greater( compare_result );        
    iter_node = iter_node->child[dir];                                
40009678:	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) {                                                 
4000967c:	80 a7 60 00 	cmp  %i5, 0                                    
40009680:	32 bf ff f0 	bne,a   40009640 <rtems_rbheap_free+0x4c>      
40009684:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
                                                                      
  return rtems_rbheap_chunk_of_node(                                  
40009688:	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) {                                         
4000968c:	80 a7 7f f8 	cmp  %i5, -8                                   
40009690:	02 80 00 06 	be  400096a8 <rtems_rbheap_free+0xb4>          
40009694:	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);            
40009698:	c2 06 ff f8 	ld  [ %i3 + -8 ], %g1                          
4000969c:	80 a0 60 00 	cmp  %g1, 0                                    
400096a0:	02 80 00 06 	be  400096b8 <rtems_rbheap_free+0xc4>          
400096a4:	b0 10 20 0e 	mov  0xe, %i0                                  
      sc = RTEMS_INVALID_ID;                                          
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400096a8:	81 c7 e0 08 	ret                                            
400096ac:	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(                                  
400096b0:	10 bf ff f7 	b  4000968c <rtems_rbheap_free+0x98>           
400096b4:	ba 06 ff f8 	add  %i3, -8, %i5                              
400096b8:	c2 06 ff fc 	ld  [ %i3 + -4 ], %g1                          
400096bc:	80 a0 60 00 	cmp  %g1, 0                                    
400096c0:	12 bf ff fa 	bne  400096a8 <rtems_rbheap_free+0xb4>         <== NEVER TAKEN
400096c4:	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(                                  
400096c8:	40 00 07 92 	call  4000b510 <_RBTree_Next_unprotected>      
400096cc:	90 10 00 1b 	mov  %i3, %o0                                  
400096d0:	92 10 20 01 	mov  1, %o1                                    
400096d4:	b2 10 00 08 	mov  %o0, %i1                                  
400096d8:	40 00 07 8e 	call  4000b510 <_RBTree_Next_unprotected>      
400096dc:	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);         
400096e0:	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(                                  
400096e4:	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);         
400096e8:	94 10 00 1d 	mov  %i5, %o2                                  
400096ec:	7f ff ff 10 	call  4000932c <check_and_merge>               
400096f0:	90 10 00 1a 	mov  %i2, %o0                                  
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
400096f4:	c2 06 80 00 	ld  [ %i2 ], %g1                               
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
400096f8:	f4 26 ff fc 	st  %i2, [ %i3 + -4 ]                          
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
400096fc:	fa 26 80 00 	st  %i5, [ %i2 ]                               
  the_node->next        = before_node;                                
40009700:	c2 26 ff f8 	st  %g1, [ %i3 + -8 ]                          
  before_node->previous = the_node;                                   
40009704:	fa 20 60 04 	st  %i5, [ %g1 + 4 ]                           
        add_to_chain(free_chain, chunk);                              
        check_and_merge(free_chain, chunk_tree, chunk, pred);         
40009708:	90 10 00 1a 	mov  %i2, %o0                                  
4000970c:	92 10 00 1c 	mov  %i4, %o1                                  
40009710:	94 10 00 1d 	mov  %i5, %o2                                  
40009714:	96 06 7f f8 	add  %i1, -8, %o3                              
40009718:	7f ff ff 05 	call  4000932c <check_and_merge>               
4000971c:	b0 10 20 00 	clr  %i0                                       
40009720:	81 c7 e0 08 	ret                                            
40009724:	81 e8 00 00 	restore                                        
      sc = RTEMS_INVALID_ID;                                          
    }                                                                 
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
40009728:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000972c:	91 e8 20 04 	restore  %g0, 4, %o0                           <== NOT EXECUTED
                                                                      

400093c4 <rtems_rbheap_initialize>: uintptr_t area_size, uintptr_t alignment, rtems_rbheap_extend_descriptors extend_descriptors, void *handler_arg ) {
400093c4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc = RTEMS_SUCCESSFUL;                            
                                                                      
  if (alignment > 0) {                                                
400093c8:	80 a6 e0 00 	cmp  %i3, 0                                    
400093cc:	12 80 00 04 	bne  400093dc <rtems_rbheap_initialize+0x18>   
400093d0:	82 10 20 0a 	mov  0xa, %g1                                  
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
400093d4:	81 c7 e0 08 	ret                                            
400093d8:	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;                               
400093dc:	90 10 00 19 	mov  %i1, %o0                                  
400093e0:	92 10 00 1b 	mov  %i3, %o1                                  
400093e4:	40 00 2f ce 	call  4001531c <.urem>                         
400093e8:	b4 06 40 1a 	add  %i1, %i2, %i2                             
                                                                      
  if (excess > 0) {                                                   
400093ec:	80 a2 20 00 	cmp  %o0, 0                                    
400093f0:	32 80 00 09 	bne,a   40009414 <rtems_rbheap_initialize+0x50>
400093f4:	a0 06 40 1b 	add  %i1, %i3, %l0                             
400093f8:	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) {
400093fc:	80 88 60 ff 	btst  0xff, %g1                                
40009400:	12 80 00 0b 	bne  4000942c <rtems_rbheap_initialize+0x68>   <== ALWAYS TAKEN
40009404:	a0 10 00 19 	mov  %i1, %l0                                  
        insert_into_tree(chunk_tree, first);                          
      } else {                                                        
        sc = RTEMS_NO_MEMORY;                                         
      }                                                               
    } else {                                                          
      sc = RTEMS_INVALID_ADDRESS;                                     
40009408:	82 10 20 09 	mov  9, %g1                                    <== NOT EXECUTED
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
4000940c:	81 c7 e0 08 	ret                                            
40009410:	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;                                      
40009414:	a0 24 00 08 	sub  %l0, %o0, %l0                             
40009418:	80 a4 00 19 	cmp  %l0, %i1                                  
4000941c:	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) {
40009420:	80 88 60 ff 	btst  0xff, %g1                                
40009424:	02 bf ff fa 	be  4000940c <rtems_rbheap_initialize+0x48>    
40009428:	82 10 20 09 	mov  9, %g1                                    
4000942c:	80 a6 40 1a 	cmp  %i1, %i2                                  
40009430:	1a bf ff f7 	bcc  4000940c <rtems_rbheap_initialize+0x48>   
40009434:	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;                               
40009438:	90 10 00 1a 	mov  %i2, %o0                                  
4000943c:	40 00 2f b8 	call  4001531c <.urem>                         
40009440:	92 10 00 1b 	mov  %i3, %o1                                  
                                                                      
  return value - excess;                                              
40009444:	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) {
40009448:	80 a4 00 1a 	cmp  %l0, %i2                                  
4000944c:	1a bf ff e2 	bcc  400093d4 <rtems_rbheap_initialize+0x10>   
40009450:	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 );                        
40009454:	82 06 20 04 	add  %i0, 4, %g1                               
                                                                      
  head->next = tail;                                                  
40009458:	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 );                        
4000945c:	82 06 20 0c 	add  %i0, 0xc, %g1                             
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
40009460:	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;                           
40009464:	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 );                        
40009468:	84 06 20 10 	add  %i0, 0x10, %g2                            
4000946c:	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;                    
40009470:	03 10 00 24 	sethi  %hi(0x40009000), %g1                    
40009474:	82 10 62 b4 	or  %g1, 0x2b4, %g1	! 400092b4 <chunk_compare> 
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
40009478:	c0 26 20 04 	clr  [ %i0 + 4 ]                               
4000947c:	c2 26 20 28 	st  %g1, [ %i0 + 0x28 ]                        
  tail->previous = head;                                              
40009480:	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;                                              
40009484:	c0 26 20 10 	clr  [ %i0 + 0x10 ]                            
)                                                                     
{                                                                     
  Chain_Node *head = _Chain_Head( the_chain );                        
  Chain_Node *tail = _Chain_Tail( the_chain );                        
                                                                      
  head->next = tail;                                                  
40009488:	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;                                
4000948c:	c0 26 20 18 	clr  [ %i0 + 0x18 ]                            
  the_rbtree->root             = NULL;                                
40009490:	c0 26 20 1c 	clr  [ %i0 + 0x1c ]                            
  the_rbtree->first[0]         = NULL;                                
40009494:	c0 26 20 20 	clr  [ %i0 + 0x20 ]                            
  the_rbtree->first[1]         = NULL;                                
40009498:	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;                                 
4000949c:	f6 26 20 30 	st  %i3, [ %i0 + 0x30 ]                        
      control->handler_arg = handler_arg;                             
400094a0:	fa 26 20 38 	st  %i5, [ %i0 + 0x38 ]                        
      control->extend_descriptors = extend_descriptors;               
400094a4:	f8 26 20 34 	st  %i4, [ %i0 + 0x34 ]                        
                                                                      
      first = get_chunk(control);                                     
400094a8:	7f ff ff 87 	call  400092c4 <get_chunk>                     
400094ac:	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;                                         
400094b0:	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) {                                            
400094b4:	80 a2 20 00 	cmp  %o0, 0                                    
400094b8:	02 bf ff c7 	be  400093d4 <rtems_rbheap_initialize+0x10>    
400094bc:	92 10 00 08 	mov  %o0, %o1                                  
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
  before_node           = after_node->next;                           
400094c0:	c2 06 00 00 	ld  [ %i0 ], %g1                               
        first->begin = aligned_begin;                                 
        first->size = aligned_end - aligned_begin;                    
400094c4:	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;                                 
400094c8:	e0 22 20 18 	st  %l0, [ %o0 + 0x18 ]                        
        first->size = aligned_end - aligned_begin;                    
400094cc:	f4 22 20 1c 	st  %i2, [ %o0 + 0x1c ]                        
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  Chain_Node *before_node;                                            
                                                                      
  the_node->previous    = after_node;                                 
400094d0:	f0 22 20 04 	st  %i0, [ %o0 + 4 ]                           
  before_node           = after_node->next;                           
  after_node->next      = the_node;                                   
400094d4:	d0 26 00 00 	st  %o0, [ %i0 ]                               
  the_node->next        = before_node;                                
400094d8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  before_node->previous = the_node;                                   
400094dc:	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);                
400094e0:	92 02 60 08 	add  %o1, 8, %o1                               
400094e4:	40 00 07 3c 	call  4000b1d4 <_RBTree_Insert_unprotected>    
400094e8:	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;                            
400094ec:	10 bf ff ba 	b  400093d4 <rtems_rbheap_initialize+0x10>     
400094f0:	82 10 20 00 	clr  %g1                                       
                                                                      

4001c2e0 <rtems_rfs_bitmap_create_search>: int rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control) {
4001c2e0:	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);                     
4001c2e4:	90 10 00 18 	mov  %i0, %o0                                  
  return 0;                                                           
}                                                                     
                                                                      
int                                                                   
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)    
{                                                                     
4001c2e8:	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);                     
4001c2ec:	7f ff fe 32 	call  4001bbb4 <rtems_rfs_bitmap_load_map>     
4001c2f0:	92 07 bf fc 	add  %fp, -4, %o1                              
  if (rc > 0)                                                         
4001c2f4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001c2f8:	24 80 00 04 	ble,a   4001c308 <rtems_rfs_bitmap_create_search+0x28>
4001c2fc:	de 07 60 14 	ld  [ %i5 + 0x14 ], %o7                        
      bit++;                                                          
    map++;                                                            
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001c300:	81 c7 e0 08 	ret                                            
4001c304:	81 e8 00 00 	restore                                        
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  control->free = 0;                                                  
  search_map = control->search_bits;                                  
  size = control->size;                                               
4001c308:	f8 07 60 0c 	ld  [ %i5 + 0xc ], %i4                         
                                                                      
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
  if (rc > 0)                                                         
    return rc;                                                        
                                                                      
  control->free = 0;                                                  
4001c30c:	c0 27 60 10 	clr  [ %i5 + 0x10 ]                            
  search_map = control->search_bits;                                  
  size = control->size;                                               
  bit = 0;                                                            
                                                                      
  *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                       
4001c310:	82 10 3f ff 	mov  -1, %g1                                   
4001c314:	c2 23 c0 00 	st  %g1, [ %o7 ]                               
4001c318:	f4 07 bf fc 	ld  [ %fp + -4 ], %i2                          
    return rc;                                                        
                                                                      
  control->free = 0;                                                  
  search_map = control->search_bits;                                  
  size = control->size;                                               
  bit = 0;                                                            
4001c31c:	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);                 
4001c320:	98 10 20 20 	mov  0x20, %o4                                 
4001c324:	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)                                                        
4001c328:	80 a7 20 00 	cmp  %i4, 0                                    
4001c32c:	02 80 00 20 	be  4001c3ac <rtems_rfs_bitmap_create_search+0xcc><== NEVER TAKEN
4001c330:	b6 10 20 01 	mov  1, %i3                                    
  {                                                                   
    rtems_rfs_bitmap_element bits;                                    
    int                      available;                               
    if (size < rtems_rfs_bitmap_element_bits ())                      
4001c334:	80 a7 20 1f 	cmp  %i4, 0x1f                                 
4001c338:	38 80 00 1f 	bgu,a   4001c3b4 <rtems_rfs_bitmap_create_search+0xd4>
4001c33c:	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;                                                      
4001c340:	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);                 
4001c344:	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;                                               
4001c348:	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);                 
4001c34c:	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;                                               
4001c350:	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;                                                      
4001c354:	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))  
4001c358:	80 a0 e0 00 	cmp  %g3, 0                                    
4001c35c:	02 80 00 0e 	be  4001c394 <rtems_rfs_bitmap_create_search+0xb4>
4001c360:	80 a6 60 20 	cmp  %i1, 0x20                                 
4001c364:	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);                     
4001c368:	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))                         
4001c36c:	80 88 80 03 	btst  %g2, %g3                                 
4001c370:	02 80 00 05 	be  4001c384 <rtems_rfs_bitmap_create_search+0xa4>
4001c374:	82 00 60 01 	inc  %g1                                       
          control->free++;                                            
4001c378:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
4001c37c:	84 00 a0 01 	inc  %g2                                       
4001c380:	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++)                                 
4001c384:	80 a1 00 01 	cmp  %g4, %g1                                  
4001c388:	14 bf ff f9 	bg  4001c36c <rtems_rfs_bitmap_create_search+0x8c>
4001c38c:	85 2e c0 01 	sll  %i3, %g1, %g2                             
          control->free++;                                            
    }                                                                 
                                                                      
    size -= available;                                                
                                                                      
    if (bit == rtems_rfs_bitmap_element_bits ())                      
4001c390:	80 a6 60 20 	cmp  %i1, 0x20                                 
4001c394:	02 80 00 0b 	be  4001c3c0 <rtems_rfs_bitmap_create_search+0xe0>
4001c398:	b8 27 00 18 	sub  %i4, %i0, %i4                             
      bit = 0;                                                        
      search_map++;                                                   
      *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                   
    }                                                                 
    else                                                              
      bit++;                                                          
4001c39c:	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)                                                        
4001c3a0:	80 a7 20 00 	cmp  %i4, 0                                    
4001c3a4:	12 bf ff e4 	bne  4001c334 <rtems_rfs_bitmap_create_search+0x54>
4001c3a8:	b4 06 a0 04 	add  %i2, 4, %i2                               
    else                                                              
      bit++;                                                          
    map++;                                                            
  }                                                                   
                                                                      
  return 0;                                                           
4001c3ac:	81 c7 e0 08 	ret                                            
4001c3b0:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                     rtems_rfs_bitmap_mask_section (0, size));
      available = size;                                               
    }                                                                 
    else                                                              
    {                                                                 
      bits      = *map;                                               
4001c3b4:	b0 10 20 20 	mov  0x20, %i0                                 
      available = rtems_rfs_bitmap_element_bits ();                   
4001c3b8:	10 bf ff e8 	b  4001c358 <rtems_rfs_bitmap_create_search+0x78>
4001c3bc:	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;                   
4001c3c0:	82 10 3f ff 	mov  -1, %g1                                   
                                                                      
    size -= available;                                                
                                                                      
    if (bit == rtems_rfs_bitmap_element_bits ())                      
    {                                                                 
      bit = 0;                                                        
4001c3c4:	b2 10 20 00 	clr  %i1                                       
      search_map++;                                                   
      *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;                   
4001c3c8:	c2 23 e0 04 	st  %g1, [ %o7 + 4 ]                           
    size -= available;                                                
                                                                      
    if (bit == rtems_rfs_bitmap_element_bits ())                      
    {                                                                 
      bit = 0;                                                        
      search_map++;                                                   
4001c3cc:	10 bf ff f5 	b  4001c3a0 <rtems_rfs_bitmap_create_search+0xc0>
4001c3d0:	9e 03 e0 04 	add  %o7, 4, %o7                               
                                                                      

4001bbb4 <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) {
4001bbb4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (!control->buffer)                                               
4001bbb8:	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)             
{                                                                     
4001bbbc:	ba 10 00 18 	mov  %i0, %i5                                  
  int rc;                                                             
                                                                      
  if (!control->buffer)                                               
4001bbc0:	80 a0 60 00 	cmp  %g1, 0                                    
4001bbc4:	02 80 00 0f 	be  4001bc00 <rtems_rfs_bitmap_load_map+0x4c>  
4001bbc8:	b0 10 20 06 	mov  6, %i0                                    
    return ENXIO;                                                     
                                                                      
  *map = NULL;                                                        
4001bbcc:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  rc = rtems_rfs_buffer_handle_request (control->fs,                  
4001bbd0:	d4 07 60 08 	ld  [ %i5 + 8 ], %o2                           
4001bbd4:	d0 07 60 04 	ld  [ %i5 + 4 ], %o0                           
4001bbd8:	d2 07 40 00 	ld  [ %i5 ], %o1                               
4001bbdc:	40 00 07 11 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001bbe0:	96 10 20 01 	mov  1, %o3                                    
                                        control->buffer,              
                                        control->block,               
                                        true);                        
  if (rc)                                                             
4001bbe4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001bbe8:	12 80 00 06 	bne  4001bc00 <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
4001bbec:	01 00 00 00 	nop                                            
    return rc;                                                        
                                                                      
  *map = rtems_rfs_buffer_data (control->buffer);                     
4001bbf0:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001bbf4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
4001bbf8:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001bbfc:	c2 26 40 00 	st  %g1, [ %i1 ]                               
  return 0;                                                           
}                                                                     
4001bc00:	81 c7 e0 08 	ret                                            
4001bc04:	81 e8 00 00 	restore                                        
                                                                      

4001c1f8 <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) {
4001c1f8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int                  rc = 0;                                        
                                                                      
  /*                                                                  
   * By default we assume the allocation failed.                      
   */                                                                 
  *allocated = false;                                                 
4001c1fc:	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;                                                  
4001c200:	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))          
4001c204:	80 a7 60 00 	cmp  %i5, 0                                    
4001c208:	06 80 00 1f 	bl  4001c284 <rtems_rfs_bitmap_map_alloc+0x8c> 
4001c20c:	80 a6 60 00 	cmp  %i1, 0                                    
4001c210:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4001c214:	80 a7 40 01 	cmp  %i5, %g1                                  
4001c218:	1a 80 00 1b 	bcc  4001c284 <rtems_rfs_bitmap_map_alloc+0x8c>
4001c21c:	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;                                              
4001c220:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
      rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001c224:	90 10 00 18 	mov  %i0, %o0                                  
4001c228:	92 10 00 1b 	mov  %i3, %o1                                  
4001c22c:	94 10 00 1a 	mov  %i2, %o2                                  
4001c230:	7f ff fe 76 	call  4001bc08 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001c234:	96 10 20 01 	mov  1, %o3                                    
                                               window, 1);            
      if ((rc > 0) || *allocated)                                     
4001c238:	80 a2 20 00 	cmp  %o0, 0                                    
4001c23c:	14 80 00 27 	bg  4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
4001c240:	01 00 00 00 	nop                                            
4001c244:	c2 0e 80 00 	ldub  [ %i2 ], %g1                             
4001c248:	80 a0 60 00 	cmp  %g1, 0                                    
4001c24c:	12 80 00 23 	bne  4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001c250:	80 a6 60 00 	cmp  %i1, 0                                    
        break;                                                        
    }                                                                 
                                                                      
    if (lower_seed >= 0)                                              
4001c254:	36 80 00 15 	bge,a   4001c2a8 <rtems_rfs_bitmap_map_alloc+0xb0>
4001c258:	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)                                   
4001c25c:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4001c260:	80 a0 40 1d 	cmp  %g1, %i5                                  
4001c264:	38 80 00 02 	bgu,a   4001c26c <rtems_rfs_bitmap_map_alloc+0x74>
4001c268:	ba 07 68 00 	add  %i5, 0x800, %i5                           
      upper_seed += window;                                           
    if (lower_seed >= 0)                                              
4001c26c:	80 a6 60 00 	cmp  %i1, 0                                    
4001c270:	06 bf ff e5 	bl  4001c204 <rtems_rfs_bitmap_map_alloc+0xc>  
4001c274:	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))          
4001c278:	16 bf ff e6 	bge  4001c210 <rtems_rfs_bitmap_map_alloc+0x18><== ALWAYS TAKEN
4001c27c:	b2 06 78 00 	add  %i1, -2048, %i1                           
         || ((lower_seed >= 0) && (lower_seed < control->size)))      
4001c280:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
4001c284:	06 80 00 15 	bl  4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0> 
4001c288:	01 00 00 00 	nop                                            
4001c28c:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
4001c290:	80 a6 40 01 	cmp  %i1, %g1                                  
4001c294:	1a 80 00 11 	bcc  4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0>
4001c298:	80 a0 40 1d 	cmp  %g1, %i5                                  
  {                                                                   
    /*                                                                
     * Search up first so bits allocated in succession are grouped together.
     */                                                               
    if (upper_seed < control->size)                                   
4001c29c:	38 bf ff e2 	bgu,a   4001c224 <rtems_rfs_bitmap_map_alloc+0x2c><== NEVER TAKEN
4001c2a0:	fa 26 c0 00 	st  %i5, [ %i3 ]                               <== NOT EXECUTED
        break;                                                        
    }                                                                 
                                                                      
    if (lower_seed >= 0)                                              
    {                                                                 
      *bit = lower_seed;                                              
4001c2a4:	f2 26 c0 00 	st  %i1, [ %i3 ]                               
      rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
4001c2a8:	90 10 00 18 	mov  %i0, %o0                                  
4001c2ac:	92 10 00 1b 	mov  %i3, %o1                                  
4001c2b0:	94 10 00 1a 	mov  %i2, %o2                                  
4001c2b4:	7f ff fe 55 	call  4001bc08 <rtems_rfs_search_map_for_clear_bit.constprop.1>
4001c2b8:	96 10 3f ff 	mov  -1, %o3                                   
                                               window, -1);           
      if ((rc > 0) || *allocated)                                     
4001c2bc:	80 a2 20 00 	cmp  %o0, 0                                    
4001c2c0:	14 80 00 06 	bg  4001c2d8 <rtems_rfs_bitmap_map_alloc+0xe0> <== NEVER TAKEN
4001c2c4:	01 00 00 00 	nop                                            
4001c2c8:	c2 0e 80 00 	ldub  [ %i2 ], %g1                             
4001c2cc:	80 a0 60 00 	cmp  %g1, 0                                    
4001c2d0:	22 bf ff e4 	be,a   4001c260 <rtems_rfs_bitmap_map_alloc+0x68>
4001c2d4:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
    if (lower_seed >= 0)                                              
      lower_seed -= window;                                           
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001c2d8:	81 c7 e0 08 	ret                                            
4001c2dc:	91 e8 20 00 	restore  %g0, 0, %o0                           
                                                                      

4001bee0 <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);
4001bee0:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
4001bee4:	90 20 00 08 	neg  %o0                                       <== NOT EXECUTED
  return mask;                                                        
}                                                                     
4001bee8:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
4001beec:	91 30 40 08 	srl  %g1, %o0, %o0                             <== NOT EXECUTED
                                                                      

4001bef0 <rtems_rfs_bitmap_mask_section>: rtems_rfs_bitmap_element rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end) {
4001bef0:	82 10 00 08 	mov  %o0, %g1                                  <== NOT EXECUTED
  rtems_rfs_bitmap_element mask = 0;                                  
  if (end > start)                                                    
4001bef4:	80 a2 40 01 	cmp  %o1, %g1                                  <== NOT EXECUTED
4001bef8:	08 80 00 06 	bleu  4001bf10 <rtems_rfs_bitmap_mask_section+0x20><== NOT EXECUTED
4001befc:	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);                 
4001bf00:	92 20 40 09 	sub  %g1, %o1, %o1                             <== NOT EXECUTED
4001bf04:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
4001bf08:	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;              
4001bf0c:	91 2a 00 01 	sll  %o0, %g1, %o0                             <== NOT EXECUTED
  return mask;                                                        
}                                                                     
4001bf10:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
                                                                      

4001c630 <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) {
4001c630:	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);     
4001c634:	96 10 20 01 	mov  1, %o3                                    
4001c638:	90 10 00 18 	mov  %i0, %o0                                  
4001c63c:	92 10 00 19 	mov  %i1, %o1                                  
4001c640:	40 00 04 78 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001c644:	94 10 00 1a 	mov  %i2, %o2                                  
  if (rc > 0)                                                         
4001c648:	80 a2 20 00 	cmp  %o0, 0                                    
4001c64c:	24 80 00 04 	ble,a   4001c65c <rtems_rfs_block_find_indirect+0x2c><== ALWAYS TAKEN
4001c650:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
    *result = 0;                                                      
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001c654:	81 c7 e0 08 	ret                                            
4001c658:	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);              
4001c65c:	83 2e e0 02 	sll  %i3, 2, %g1                               
4001c660:	c6 00 a0 1c 	ld  [ %g2 + 0x1c ], %g3                        
  if ((*result + 1) == 0)                                             
    *result = 0;                                                      
                                                                      
  if (*result >= rtems_rfs_fs_blocks (fs))                            
4001c664:	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);              
4001c668:	fa 08 c0 01 	ldub  [ %g3 + %g1 ], %i5                       
4001c66c:	84 00 c0 01 	add  %g3, %g1, %g2                             
4001c670:	c2 08 a0 03 	ldub  [ %g2 + 3 ], %g1                         
4001c674:	c6 08 a0 01 	ldub  [ %g2 + 1 ], %g3                         
4001c678:	c4 08 a0 02 	ldub  [ %g2 + 2 ], %g2                         
4001c67c:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
4001c680:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001c684:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001c688:	82 10 40 1d 	or  %g1, %i5, %g1                              
4001c68c:	82 10 40 03 	or  %g1, %g3, %g1                              
4001c690:	82 10 40 02 	or  %g1, %g2, %g1                              
  if ((*result + 1) == 0)                                             
    *result = 0;                                                      
4001c694:	84 38 00 01 	xnor  %g0, %g1, %g2                            
4001c698:	80 a0 00 02 	cmp  %g0, %g2                                  
4001c69c:	84 60 20 00 	subx  %g0, 0, %g2                              
4001c6a0:	82 08 40 02 	and  %g1, %g2, %g1                             
4001c6a4:	c2 27 00 00 	st  %g1, [ %i4 ]                               
                                                                      
  if (*result >= rtems_rfs_fs_blocks (fs))                            
4001c6a8:	80 a1 00 01 	cmp  %g4, %g1                                  
4001c6ac:	18 bf ff ea 	bgu  4001c654 <rtems_rfs_block_find_indirect+0x24><== ALWAYS TAKEN
4001c6b0:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))                 
4001c6b4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001c6b8:	7f ff e2 7b 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001c6bc:	13 00 00 04 	sethi  %hi(0x1000), %o1                        <== NOT EXECUTED
4001c6c0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001c6c4:	32 80 00 06 	bne,a   4001c6dc <rtems_rfs_block_find_indirect+0xac><== NOT EXECUTED
4001c6c8:	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;                                                      
4001c6cc:	c0 27 00 00 	clr  [ %i4 ]                                   <== NOT EXECUTED
4001c6d0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001c6d4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c6d8:	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:"        
4001c6dc:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001c6e0:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001c6e4:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
4001c6e8:	40 00 22 a5 	call  4002517c <printf>                        <== NOT EXECUTED
4001c6ec:	90 12 22 38 	or  %o0, 0x238, %o0                            <== NOT EXECUTED
              " block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
    *result = 0;                                                      
4001c6f0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001c6f4:	10 bf ff f8 	b  4001c6d4 <rtems_rfs_block_find_indirect+0xa4><== NOT EXECUTED
4001c6f8:	c0 27 00 00 	clr  [ %i4 ]                                   <== NOT EXECUTED
                                                                      

4001c75c <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) {
4001c75c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  if (pos == 0)                                                       
4001c760:	80 96 40 1a 	orcc  %i1, %i2, %g0                            <== NOT EXECUTED
4001c764:	02 80 00 11 	be  4001c7a8 <rtems_rfs_block_get_block_size+0x4c><== NOT EXECUTED
4001c768:	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;            
4001c76c:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           <== NOT EXECUTED
4001c770:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
4001c774:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4001c778:	40 00 56 d4 	call  400322c8 <__udivdi3>                     <== NOT EXECUTED
4001c77c:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001c780:	92 02 60 01 	inc  %o1                                       <== NOT EXECUTED
    size->offset = pos % rtems_rfs_fs_block_size (fs);                
4001c784:	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;            
4001c788:	d2 26 c0 00 	st  %o1, [ %i3 ]                               <== NOT EXECUTED
    size->offset = pos % rtems_rfs_fs_block_size (fs);                
4001c78c:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4001c790:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001c794:	40 00 57 a1 	call  40032618 <__umoddi3>                     <== NOT EXECUTED
4001c798:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
4001c79c:	d2 26 e0 04 	st  %o1, [ %i3 + 4 ]                           <== NOT EXECUTED
4001c7a0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c7a4:	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;                                                    
4001c7a8:	c0 26 c0 00 	clr  [ %i3 ]                                   <== NOT EXECUTED
  size->offset = 0;                                                   
4001c7ac:	c0 26 e0 04 	clr  [ %i3 + 4 ]                               <== NOT EXECUTED
4001c7b0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c7b4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001c994 <rtems_rfs_block_map_close>: int rtems_rfs_block_map_close (rtems_rfs_file_system* fs, rtems_rfs_block_map* map) {
4001c994:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
  int brc;                                                            
                                                                      
  if (map->dirty && map->inode)                                       
4001c998:	c2 0e 40 00 	ldub  [ %i1 ], %g1                             
}                                                                     
                                                                      
int                                                                   
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,                 
                           rtems_rfs_block_map*   map)                
{                                                                     
4001c99c:	ba 10 00 18 	mov  %i0, %i5                                  
  int rc = 0;                                                         
  int brc;                                                            
                                                                      
  if (map->dirty && map->inode)                                       
4001c9a0:	80 a0 60 00 	cmp  %g1, 0                                    
4001c9a4:	02 80 00 0b 	be  4001c9d0 <rtems_rfs_block_map_close+0x3c>  
4001c9a8:	b0 10 20 00 	clr  %i0                                       
4001c9ac:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           
4001c9b0:	80 a2 60 00 	cmp  %o1, 0                                    
4001c9b4:	22 80 00 08 	be,a   4001c9d4 <rtems_rfs_block_map_close+0x40><== NEVER TAKEN
4001c9b8:	92 06 60 38 	add  %i1, 0x38, %o1                            <== NOT EXECUTED
  {                                                                   
    brc = rtems_rfs_inode_load (fs, map->inode);                      
4001c9bc:	7f ff da e6 	call  40013554 <rtems_rfs_inode_load>          
4001c9c0:	90 10 00 1d 	mov  %i5, %o0                                  
    if (brc > 0)                                                      
4001c9c4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001c9c8:	04 80 00 11 	ble  4001ca0c <rtems_rfs_block_map_close+0x78> <== ALWAYS TAKEN
4001c9cc:	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);                       
4001c9d0:	92 06 60 38 	add  %i1, 0x38, %o1                            
                                                                      
      map->dirty = false;                                             
    }                                                                 
  }                                                                   
                                                                      
  map->inode = NULL;                                                  
4001c9d4:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
4001c9d8:	40 00 03 18 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001c9dc:	90 10 00 1d 	mov  %i5, %o0                                  
4001c9e0:	90 10 00 1d 	mov  %i5, %o0                                  
  handle->dirty = false;                                              
4001c9e4:	c0 2e 60 38 	clrb  [ %i1 + 0x38 ]                           
  handle->bnum  = 0;                                                  
4001c9e8:	c0 26 60 3c 	clr  [ %i1 + 0x3c ]                            
  handle->buffer = NULL;                                              
4001c9ec:	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);                       
4001c9f0:	40 00 03 12 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001c9f4:	92 06 60 44 	add  %i1, 0x44, %o1                            
  handle->dirty = false;                                              
4001c9f8:	c0 2e 60 44 	clrb  [ %i1 + 0x44 ]                           
  handle->bnum  = 0;                                                  
4001c9fc:	c0 26 60 48 	clr  [ %i1 + 0x48 ]                            
  handle->buffer = NULL;                                              
4001ca00:	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;                                                          
}                                                                     
4001ca04:	81 c7 e0 08 	ret                                            
4001ca08:	81 e8 00 00 	restore                                        
  int brc;                                                            
                                                                      
  if (map->dirty && map->inode)                                       
  {                                                                   
    brc = rtems_rfs_inode_load (fs, map->inode);                      
    if (brc > 0)                                                      
4001ca0c:	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);                      
4001ca10:	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]);    
4001ca14:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
4001ca18:	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);       
4001ca1c:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
4001ca20:	86 01 20 06 	add  %g4, 6, %g3                               
4001ca24:	87 28 e0 02 	sll  %g3, 2, %g3                               
4001ca28:	b6 06 c0 03 	add  %i3, %g3, %i3                             
4001ca2c:	b5 30 a0 18 	srl  %g2, 0x18, %i2                            
4001ca30:	f4 2e e0 04 	stb  %i2, [ %i3 + 4 ]                          
4001ca34:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
4001ca38:	b5 30 a0 10 	srl  %g2, 0x10, %i2                            
4001ca3c:	b6 06 c0 03 	add  %i3, %g3, %i3                             
4001ca40:	f4 2e e0 05 	stb  %i2, [ %i3 + 5 ]                          
4001ca44:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
4001ca48:	b5 30 a0 08 	srl  %g2, 8, %i2                               
4001ca4c:	b6 06 c0 03 	add  %i3, %g3, %i3                             
4001ca50:	f4 2e e0 06 	stb  %i2, [ %i3 + 6 ]                          
4001ca54:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
                                                                      
    if (rc == 0)                                                      
    {                                                                 
      int b;                                                          
                                                                      
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
4001ca58:	88 01 20 01 	inc  %g4                                       
4001ca5c:	86 06 c0 03 	add  %i3, %g3, %g3                             
4001ca60:	c4 28 e0 07 	stb  %g2, [ %g3 + 7 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001ca64:	f0 28 60 10 	stb  %i0, [ %g1 + 0x10 ]                       
4001ca68:	b8 07 20 04 	add  %i4, 4, %i4                               
4001ca6c:	80 a1 20 05 	cmp  %g4, 5                                    
4001ca70:	12 bf ff e9 	bne  4001ca14 <rtems_rfs_block_map_close+0x80> 
4001ca74:	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);  
4001ca78:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
4001ca7c:	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);      
4001ca80:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
4001ca84:	b9 30 e0 18 	srl  %g3, 0x18, %i4                            
4001ca88:	f8 29 20 0c 	stb  %i4, [ %g4 + 0xc ]                        
4001ca8c:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
4001ca90:	b9 30 e0 10 	srl  %g3, 0x10, %i4                            
4001ca94:	f8 29 20 0d 	stb  %i4, [ %g4 + 0xd ]                        
4001ca98:	c8 00 a0 0c 	ld  [ %g2 + 0xc ], %g4                         
4001ca9c:	b9 30 e0 08 	srl  %g3, 8, %i4                               
4001caa0:	f8 29 20 0e 	stb  %i4, [ %g4 + 0xe ]                        
4001caa4:	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);            
4001caa8:	90 10 00 1d 	mov  %i5, %o0                                  
4001caac:	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);
4001cab0:	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);    
4001cab4:	f6 0e 60 0e 	ldub  [ %i1 + 0xe ], %i3                       
4001cab8:	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);                      
4001cabc:	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);    
4001cac0:	c6 06 60 0c 	ld  [ %i1 + 0xc ], %g3                         
4001cac4:	f6 2f 20 0a 	stb  %i3, [ %i4 + 0xa ]                        
4001cac8:	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);            
4001cacc:	94 10 20 01 	mov  1, %o2                                    
4001cad0:	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);
4001cad4:	c6 06 60 04 	ld  [ %i1 + 4 ], %g3                           
4001cad8:	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);
4001cadc:	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);                      
4001cae0:	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);
4001cae4:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
4001cae8:	c8 2f 20 30 	stb  %g4, [ %i4 + 0x30 ]                       
4001caec:	c8 00 e0 0c 	ld  [ %g3 + 0xc ], %g4                         
4001caf0:	b9 30 a0 10 	srl  %g2, 0x10, %i4                            
4001caf4:	f8 29 20 31 	stb  %i4, [ %g4 + 0x31 ]                       
4001caf8:	c8 00 e0 0c 	ld  [ %g3 + 0xc ], %g4                         
4001cafc:	b9 30 a0 08 	srl  %g2, 8, %i4                               
4001cb00:	f8 29 20 32 	stb  %i4, [ %g4 + 0x32 ]                       
4001cb04:	c8 00 e0 0c 	ld  [ %g3 + 0xc ], %g4                         
4001cb08:	c4 29 20 33 	stb  %g2, [ %g4 + 0x33 ]                       
      rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
4001cb0c:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
4001cb10:	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);
4001cb14:	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);                      
4001cb18:	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);
4001cb1c:	87 31 20 18 	srl  %g4, 0x18, %g3                            
4001cb20:	c6 2f 20 34 	stb  %g3, [ %i4 + 0x34 ]                       
4001cb24:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
4001cb28:	b9 31 20 10 	srl  %g4, 0x10, %i4                            
4001cb2c:	f8 28 e0 35 	stb  %i4, [ %g3 + 0x35 ]                       
4001cb30:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
4001cb34:	b9 31 20 08 	srl  %g4, 8, %i4                               
4001cb38:	f8 28 e0 36 	stb  %i4, [ %g3 + 0x36 ]                       
4001cb3c:	c6 00 a0 0c 	ld  [ %g2 + 0xc ], %g3                         
4001cb40:	c8 28 e0 37 	stb  %g4, [ %g3 + 0x37 ]                       
                                                                      
      brc = rtems_rfs_inode_unload (fs, map->inode, true);            
4001cb44:	d2 06 60 04 	ld  [ %i1 + 4 ], %o1                           
4001cb48:	7f ff da e7 	call  400136e4 <rtems_rfs_inode_unload>        
4001cb4c:	c2 28 a0 10 	stb  %g1, [ %g2 + 0x10 ]                       
      if (brc > 0)                                                    
        rc = brc;                                                     
                                                                      
      map->dirty = false;                                             
4001cb50:	c0 2e 40 00 	clrb  [ %i1 ]                                  
4001cb54:	82 38 00 08 	xnor  %g0, %o0, %g1                            
4001cb58:	83 38 60 1f 	sra  %g1, 0x1f, %g1                            
4001cb5c:	10 bf ff 9d 	b  4001c9d0 <rtems_rfs_block_map_close+0x3c>   
4001cb60:	b0 0a 00 01 	and  %o0, %g1, %i0                             
                                                                      

4001cb64 <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) {
4001cb64:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int rc = 0;                                                         
                                                                      
  *block = 0;                                                         
4001cb68:	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))          
4001cb6c:	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)               
{                                                                     
4001cb70:	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))          
4001cb74:	80 a7 60 00 	cmp  %i5, 0                                    
4001cb78:	02 80 00 05 	be  4001cb8c <rtems_rfs_block_map_find+0x28>   
4001cb7c:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
4001cb80:	80 a7 20 00 	cmp  %i4, 0                                    
4001cb84:	02 80 00 4b 	be  4001ccb0 <rtems_rfs_block_map_find+0x14c>  <== NEVER TAKEN
4001cb88:	b0 10 20 06 	mov  6, %i0                                    
4001cb8c:	80 a7 40 1c 	cmp  %i5, %i4                                  
4001cb90:	1a 80 00 48 	bcc  4001ccb0 <rtems_rfs_block_map_find+0x14c> 
4001cb94:	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))         
4001cb98:	c2 06 60 10 	ld  [ %i1 + 0x10 ], %g1                        
4001cb9c:	80 a7 40 01 	cmp  %i5, %g1                                  
4001cba0:	22 80 00 14 	be,a   4001cbf0 <rtems_rfs_block_map_find+0x8c>
4001cba4:	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)                    
4001cba8:	80 a7 20 05 	cmp  %i4, 5                                    
4001cbac:	38 80 00 16 	bgu,a   4001cc04 <rtems_rfs_block_map_find+0xa0>
4001cbb0:	e2 04 20 34 	ld  [ %l0 + 0x34 ], %l1                        
    {                                                                 
      *block = map->blocks[bpos->bno];                                
4001cbb4:	ba 07 60 08 	add  %i5, 8, %i5                               
4001cbb8:	bb 2f 60 02 	sll  %i5, 2, %i5                               
4001cbbc:	ba 06 40 1d 	add  %i1, %i5, %i5                             
4001cbc0:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           
4001cbc4:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
    }                                                                 
  }                                                                   
                                                                      
  if (rc == 0)                                                        
  {                                                                   
    rtems_rfs_block_copy_bpos (&map->bpos, bpos);                     
4001cbc8:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001cbcc:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4001cbd0:	c4 06 80 00 	ld  [ %i2 ], %g2                               
4001cbd4:	c6 26 60 18 	st  %g3, [ %i1 + 0x18 ]                        
4001cbd8:	c4 26 60 10 	st  %g2, [ %i1 + 0x10 ]                        
4001cbdc:	c2 26 60 14 	st  %g1, [ %i1 + 0x14 ]                        
    map->bpos.block = *block;                                         
4001cbe0:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4001cbe4:	c2 26 60 18 	st  %g1, [ %i1 + 0x18 ]                        
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001cbe8:	81 c7 e0 08 	ret                                            
4001cbec:	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))         
4001cbf0:	80 a0 60 00 	cmp  %g1, 0                                    
4001cbf4:	02 bf ff ee 	be  4001cbac <rtems_rfs_block_map_find+0x48>   
4001cbf8:	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];                                
4001cbfc:	10 bf ff f3 	b  4001cbc8 <rtems_rfs_block_map_find+0x64>    
4001cc00:	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;                      
4001cc04:	90 10 00 1d 	mov  %i5, %o0                                  
4001cc08:	40 00 52 f3 	call  400317d4 <.urem>                         
4001cc0c:	92 10 00 11 	mov  %l1, %o1                                  
      singly = bpos->bno / fs->blocks_per_block;                      
4001cc10:	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;                      
4001cc14:	a6 10 00 08 	mov  %o0, %l3                                  
      singly = bpos->bno / fs->blocks_per_block;                      
4001cc18:	7f ff 96 a2 	call  400026a0 <.udiv>                         
4001cc1c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      if (map->size.count <= fs->block_map_singly_blocks)             
4001cc20:	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;                      
4001cc24:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
                                                                      
      if (map->size.count <= fs->block_map_singly_blocks)             
4001cc28:	80 a0 40 1c 	cmp  %g1, %i4                                  
4001cc2c:	1a 80 00 23 	bcc  4001ccb8 <rtems_rfs_block_map_find+0x154> <== ALWAYS TAKEN
4001cc30:	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;                               
4001cc34:	40 00 52 e8 	call  400317d4 <.urem>                         <== NOT EXECUTED
4001cc38:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
4001cc3c:	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;                               
4001cc40:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          <== NOT EXECUTED
4001cc44:	a4 10 00 08 	mov  %o0, %l2                                  <== NOT EXECUTED
                                                                      
        if (map->size.count < fs->block_map_doubly_blocks)            
4001cc48:	80 a0 40 1c 	cmp  %g1, %i4                                  <== NOT EXECUTED
4001cc4c:	08 80 00 19 	bleu  4001ccb0 <rtems_rfs_block_map_find+0x14c><== NOT EXECUTED
4001cc50:	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;                      
4001cc54:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4001cc58:	7f ff 96 92 	call  400026a0 <.udiv>                         <== NOT EXECUTED
4001cc5c:	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,                     
4001cc60:	90 02 20 08 	add  %o0, 8, %o0                               <== NOT EXECUTED
4001cc64:	83 2a 20 02 	sll  %o0, 2, %g1                               <== NOT EXECUTED
4001cc68:	82 06 40 01 	add  %i1, %g1, %g1                             <== NOT EXECUTED
4001cc6c:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           <== NOT EXECUTED
4001cc70:	92 06 60 44 	add  %i1, 0x44, %o1                            <== NOT EXECUTED
4001cc74:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001cc78:	96 10 00 12 	mov  %l2, %o3                                  <== NOT EXECUTED
4001cc7c:	7f ff fe 6d 	call  4001c630 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
4001cc80:	98 07 bf fc 	add  %fp, -4, %o4                              <== NOT EXECUTED
                                              &map->doubly_buffer,    
                                              map->blocks[doubly],    
                                              singly, &singly);       
          if (rc == 0)                                                
4001cc84:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001cc88:	12 80 00 0a 	bne  4001ccb0 <rtems_rfs_block_map_find+0x14c> <== NOT EXECUTED
4001cc8c:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
          {                                                           
            rc = rtems_rfs_block_find_indirect (fs,                   
4001cc90:	90 10 00 10 	mov  %l0, %o0                                  
4001cc94:	92 06 60 38 	add  %i1, 0x38, %o1                            
4001cc98:	96 10 00 13 	mov  %l3, %o3                                  
4001cc9c:	7f ff fe 65 	call  4001c630 <rtems_rfs_block_find_indirect> 
4001cca0:	98 10 00 1b 	mov  %i3, %o4                                  
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (rc == 0)                                                        
4001cca4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001cca8:	22 bf ff c9 	be,a   4001cbcc <rtems_rfs_block_map_find+0x68><== ALWAYS TAKEN
4001ccac:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
    rtems_rfs_block_copy_bpos (&map->bpos, bpos);                     
    map->bpos.block = *block;                                         
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001ccb0:	81 c7 e0 08 	ret                                            
4001ccb4:	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,                       
4001ccb8:	82 02 20 08 	add  %o0, 8, %g1                               
4001ccbc:	83 28 60 02 	sll  %g1, 2, %g1                               
4001ccc0:	82 06 40 01 	add  %i1, %g1, %g1                             
4001ccc4:	10 bf ff f3 	b  4001cc90 <rtems_rfs_block_map_find+0x12c>   
4001ccc8:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
                                                                      

4001cd74 <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) {
4001cd74:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int b;                                                              
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))               
4001cd78:	90 10 20 00 	clr  %o0                                       
4001cd7c:	7f ff e0 ca 	call  400150a4 <rtems_rfs_trace>               
4001cd80:	13 00 00 08 	sethi  %hi(0x2000), %o1                        
4001cd84:	80 8a 20 ff 	btst  0xff, %o0                                
4001cd88:	32 80 00 cf 	bne,a   4001d0c4 <rtems_rfs_block_map_grow+0x350><== NEVER TAKEN
4001cd8c:	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))
4001cd90:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           
4001cd94:	c2 06 20 3c 	ld  [ %i0 + 0x3c ], %g1                        
4001cd98:	84 06 80 02 	add  %i2, %g2, %g2                             
4001cd9c:	80 a0 80 01 	cmp  %g2, %g1                                  
4001cda0:	0a 80 00 04 	bcs  4001cdb0 <rtems_rfs_block_map_grow+0x3c>  <== ALWAYS TAKEN
4001cda4:	ba 10 20 1b 	mov  0x1b, %i5                                 
    map->last_data_block = block;                                     
    map->dirty = true;                                                
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001cda8:	81 c7 e0 08 	ret                                            
4001cdac:	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++)                                        
4001cdb0:	80 a6 a0 00 	cmp  %i2, 0                                    
4001cdb4:	02 80 00 de 	be  4001d12c <rtems_rfs_block_map_grow+0x3b8>  <== NEVER TAKEN
4001cdb8:	b8 10 20 00 	clr  %i4                                       
4001cdbc:	d2 06 60 20 	ld  [ %i1 + 0x20 ], %o1                        
            return rc;                                                
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001cdc0:	a2 10 20 01 	mov  1, %l1                                    
                                      singly,                         
                                      singly_block);                  
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,                   
4001cdc4:	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,
4001cdc8:	10 80 00 11 	b  4001ce0c <rtems_rfs_block_map_grow+0x98>    
4001cdcc:	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;                           
4001cdd0:	82 07 60 08 	add  %i5, 8, %g1                               
4001cdd4:	83 28 60 02 	sll  %g1, 2, %g1                               
4001cdd8:	82 06 40 01 	add  %i1, %g1, %g1                             
4001cddc:	d2 20 60 04 	st  %o1, [ %g1 + 4 ]                           
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
    }                                                                 
                                                                      
    map->size.count++;                                                
4001cde0:	ba 07 60 01 	inc  %i5                                       
    map->size.offset = 0;                                             
4001cde4:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
                                                                      
    if (b == 0)                                                       
4001cde8:	80 a7 20 00 	cmp  %i4, 0                                    
4001cdec:	12 80 00 03 	bne  4001cdf8 <rtems_rfs_block_map_grow+0x84>  <== NEVER TAKEN
4001cdf0:	fa 26 60 08 	st  %i5, [ %i1 + 8 ]                           
      *new_block = block;                                             
4001cdf4:	d2 26 c0 00 	st  %o1, [ %i3 ]                               
    map->last_data_block = block;                                     
    map->dirty = true;                                                
4001cdf8:	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++)                                        
4001cdfc:	b8 07 20 01 	inc  %i4                                       
4001ce00:	80 a7 00 1a 	cmp  %i4, %i2                                  
4001ce04:	02 80 00 ca 	be  4001d12c <rtems_rfs_block_map_grow+0x3b8>  <== ALWAYS TAKEN
4001ce08:	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,      
4001ce0c:	90 10 00 18 	mov  %i0, %o0                                  
4001ce10:	94 10 20 00 	clr  %o2                                       
4001ce14:	7f ff d8 80 	call  40013014 <rtems_rfs_group_bitmap_alloc>  
4001ce18:	96 07 bf f8 	add  %fp, -8, %o3                              
                                       false, &block);                
    if (rc > 0)                                                       
4001ce1c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001ce20:	14 bf ff e2 	bg  4001cda8 <rtems_rfs_block_map_grow+0x34>   
4001ce24:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    if (map->size.count < RTEMS_RFS_INODE_BLOCKS)                     
4001ce28:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
4001ce2c:	80 a7 60 04 	cmp  %i5, 4                                    
4001ce30:	08 bf ff e8 	bleu  4001cdd0 <rtems_rfs_block_map_grow+0x5c> 
4001ce34:	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;                
4001ce38:	e0 06 20 34 	ld  [ %i0 + 0x34 ], %l0                        
4001ce3c:	90 10 00 1d 	mov  %i5, %o0                                  
4001ce40:	40 00 52 65 	call  400317d4 <.urem>                         
4001ce44:	92 10 00 10 	mov  %l0, %o1                                  
      singly = map->size.count / fs->blocks_per_block;                
4001ce48:	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;                
4001ce4c:	a8 10 00 08 	mov  %o0, %l4                                  
      singly = map->size.count / fs->blocks_per_block;                
4001ce50:	7f ff 96 14 	call  400026a0 <.udiv>                         
4001ce54:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      if (map->size.count < fs->block_map_singly_blocks)              
4001ce58:	c2 06 20 38 	ld  [ %i0 + 0x38 ], %g1                        
4001ce5c:	80 a7 40 01 	cmp  %i5, %g1                                  
4001ce60:	1a 80 00 31 	bcc  4001cf24 <rtems_rfs_block_map_grow+0x1b0> <== NEVER TAKEN
4001ce64:	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) ||                                          
4001ce68:	80 a5 20 00 	cmp  %l4, 0                                    
4001ce6c:	02 80 00 06 	be  4001ce84 <rtems_rfs_block_map_grow+0x110>  <== NEVER TAKEN
4001ce70:	80 a5 20 05 	cmp  %l4, 5                                    
4001ce74:	12 80 00 8a 	bne  4001d09c <rtems_rfs_block_map_grow+0x328> 
4001ce78:	80 a2 20 00 	cmp  %o0, 0                                    
4001ce7c:	12 80 00 89 	bne  4001d0a0 <rtems_rfs_block_map_grow+0x32c> <== NEVER TAKEN
4001ce80:	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;         
4001ce84:	ba 1f 60 05 	xor  %i5, 5, %i5                               
          rc = rtems_rfs_block_map_indirect_alloc (fs, map,           
4001ce88:	80 a0 00 1d 	cmp  %g0, %i5                                  
                                                   &map->singly_buffer,
                                                   &map->blocks[singly],
4001ce8c:	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,           
4001ce90:	90 10 00 18 	mov  %i0, %o0                                  
                                                   &map->singly_buffer,
                                                   &map->blocks[singly],
4001ce94:	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,           
4001ce98:	92 10 00 19 	mov  %i1, %o1                                  
                                                   &map->singly_buffer,
                                                   &map->blocks[singly],
4001ce9c:	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,           
4001cea0:	94 10 00 12 	mov  %l2, %o2                                  
4001cea4:	96 02 e0 04 	add  %o3, 4, %o3                               
4001cea8:	7f ff fd 8f 	call  4001c4e4 <rtems_rfs_block_map_indirect_alloc>
4001ceac:	98 60 3f ff 	subx  %g0, -1, %o4                             
4001ceb0:	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)                                                 
4001ceb4:	80 a7 60 00 	cmp  %i5, 0                                    
4001ceb8:	14 80 00 a1 	bg  4001d13c <rtems_rfs_block_map_grow+0x3c8>  <== NEVER TAKEN
4001cebc:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          
            return rc;                                                
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
4001cec0:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001cec4:	c4 0f bf f8 	ldub  [ %fp + -8 ], %g2                        
4001cec8:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001cecc:	91 2d 20 02 	sll  %l4, 2, %o0                               
4001ced0:	c4 28 40 08 	stb  %g2, [ %g1 + %o0 ]                        
4001ced4:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001ced8:	c4 17 bf f8 	lduh  [ %fp + -8 ], %g2                        
4001cedc:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001cee0:	82 00 40 08 	add  %g1, %o0, %g1                             
4001cee4:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          
4001cee8:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001ceec:	c4 07 bf f8 	ld  [ %fp + -8 ], %g2                          
4001cef0:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001cef4:	85 30 a0 08 	srl  %g2, 8, %g2                               
4001cef8:	82 00 40 08 	add  %g1, %o0, %g1                             
4001cefc:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          
4001cf00:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001cf04:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
4001cf08:	90 00 40 08 	add  %g1, %o0, %o0                             
4001cf0c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4001cf10:	c2 2a 20 03 	stb  %g1, [ %o0 + 3 ]                          
4001cf14:	e2 2e 60 38 	stb  %l1, [ %i1 + 0x38 ]                       
4001cf18:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           
4001cf1c:	10 bf ff b1 	b  4001cde0 <rtems_rfs_block_map_grow+0x6c>    
4001cf20:	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;                      
4001cf24:	7f ff 95 df 	call  400026a0 <.udiv>                         <== NOT EXECUTED
4001cf28:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
        singly %= fs->blocks_per_block;                               
4001cf2c:	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;                      
4001cf30:	ac 10 00 08 	mov  %o0, %l6                                  <== NOT EXECUTED
        singly %= fs->blocks_per_block;                               
4001cf34:	40 00 52 28 	call  400317d4 <.urem>                         <== NOT EXECUTED
4001cf38:	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)                                              
4001cf3c:	80 a5 20 00 	cmp  %l4, 0                                    <== NOT EXECUTED
4001cf40:	12 80 00 38 	bne  4001d020 <rtems_rfs_block_map_grow+0x2ac> <== NOT EXECUTED
4001cf44:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_block_map_indirect_alloc (fs, map,           
4001cf48:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001cf4c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001cf50:	94 10 00 12 	mov  %l2, %o2                                  <== NOT EXECUTED
4001cf54:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
4001cf58:	7f ff fd 63 	call  4001c4e4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001cf5c:	98 10 20 00 	clr  %o4                                       <== NOT EXECUTED
                                                   &map->singly_buffer,
                                                   &singly_block,     
                                                   false);            
          if (rc > 0)                                                 
4001cf60:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001cf64:	14 80 00 75 	bg  4001d138 <rtems_rfs_block_map_grow+0x3c4>  <== NOT EXECUTED
4001cf68:	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) ||                                        
4001cf6c:	02 80 00 06 	be  4001cf84 <rtems_rfs_block_map_grow+0x210>  <== NOT EXECUTED
4001cf70:	80 a4 20 05 	cmp  %l0, 5                                    <== NOT EXECUTED
4001cf74:	12 80 00 5a 	bne  4001d0dc <rtems_rfs_block_map_grow+0x368> <== NOT EXECUTED
4001cf78:	80 a5 a0 00 	cmp  %l6, 0                                    <== NOT EXECUTED
4001cf7c:	12 80 00 59 	bne  4001d0e0 <rtems_rfs_block_map_grow+0x36c> <== NOT EXECUTED
4001cf80:	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;  
4001cf84:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           <== NOT EXECUTED
4001cf88:	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],
4001cf8c:	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;  
4001cf90:	82 18 80 01 	xor  %g2, %g1, %g1                             <== NOT EXECUTED
            rc = rtems_rfs_block_map_indirect_alloc (fs, map,         
4001cf94:	80 a0 00 01 	cmp  %g0, %g1                                  <== NOT EXECUTED
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
4001cf98:	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,         
4001cf9c:	98 60 3f ff 	subx  %g0, -1, %o4                             <== NOT EXECUTED
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
4001cfa0:	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,         
4001cfa4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001cfa8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001cfac:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
4001cfb0:	7f ff fd 4d 	call  4001c4e4 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
4001cfb4:	96 02 e0 04 	add  %o3, 4, %o3                               <== NOT EXECUTED
                                                     &map->doubly_buffer,
                                                     &map->blocks[doubly],
                                                     upping);         
            if (rc > 0)                                               
4001cfb8:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001cfbc:	14 80 00 54 	bg  4001d10c <rtems_rfs_block_map_grow+0x398>  <== NOT EXECUTED
4001cfc0:	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,            
4001cfc4:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001cfc8:	c4 0f bf fc 	ldub  [ %fp + -4 ], %g2                        <== NOT EXECUTED
4001cfcc:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
4001cfd0:	a1 2c 20 02 	sll  %l0, 2, %l0                               <== NOT EXECUTED
4001cfd4:	c4 28 40 10 	stb  %g2, [ %g1 + %l0 ]                        <== NOT EXECUTED
4001cfd8:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001cfdc:	c4 17 bf fc 	lduh  [ %fp + -4 ], %g2                        <== NOT EXECUTED
4001cfe0:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
4001cfe4:	82 00 40 10 	add  %g1, %l0, %g1                             <== NOT EXECUTED
4001cfe8:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          <== NOT EXECUTED
4001cfec:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001cff0:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          <== NOT EXECUTED
4001cff4:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
4001cff8:	85 30 a0 08 	srl  %g2, 8, %g2                               <== NOT EXECUTED
4001cffc:	82 00 40 10 	add  %g1, %l0, %g1                             <== NOT EXECUTED
4001d000:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          <== NOT EXECUTED
4001d004:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001d008:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        <== NOT EXECUTED
4001d00c:	a0 00 40 10 	add  %g1, %l0, %l0                             <== NOT EXECUTED
4001d010:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          <== NOT EXECUTED
4001d014:	c2 2c 20 03 	stb  %g1, [ %l0 + 3 ]                          <== NOT EXECUTED
4001d018:	10 bf ff aa 	b  4001cec0 <rtems_rfs_block_map_grow+0x14c>   <== NOT EXECUTED
4001d01c:	e2 2e 60 44 	stb  %l1, [ %i1 + 0x44 ]                       <== NOT EXECUTED
                                      singly,                         
                                      singly_block);                  
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,                   
4001d020:	ac 05 a0 08 	add  %l6, 8, %l6                               <== NOT EXECUTED
4001d024:	ad 2d a0 02 	sll  %l6, 2, %l6                               <== NOT EXECUTED
4001d028:	ac 06 40 16 	add  %i1, %l6, %l6                             <== NOT EXECUTED
4001d02c:	d4 05 a0 04 	ld  [ %l6 + 4 ], %o2                           <== NOT EXECUTED
4001d030:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001d034:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
4001d038:	40 00 01 fa 	call  4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d03c:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
                                                &map->doubly_buffer,  
                                                map->blocks[doubly],  
                                                true);                
          if (rc > 0)                                                 
4001d040:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001d044:	14 80 00 3d 	bg  4001d138 <rtems_rfs_block_map_grow+0x3c4>  <== NOT EXECUTED
4001d048:	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,
4001d04c:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001d050:	c4 00 60 1c 	ld  [ %g1 + 0x1c ], %g2                        <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d054:	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,
4001d058:	c6 08 80 10 	ldub  [ %g2 + %l0 ], %g3                       <== NOT EXECUTED
4001d05c:	82 00 80 10 	add  %g2, %l0, %g1                             <== NOT EXECUTED
4001d060:	d4 08 60 03 	ldub  [ %g1 + 3 ], %o2                         <== NOT EXECUTED
4001d064:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         <== NOT EXECUTED
4001d068:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
4001d06c:	87 28 e0 18 	sll  %g3, 0x18, %g3                            <== NOT EXECUTED
4001d070:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
4001d074:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
4001d078:	94 12 80 03 	or  %o2, %g3, %o2                              <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d07c:	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,
4001d080:	94 12 80 02 	or  %o2, %g2, %o2                              <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d084:	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,
4001d088:	94 12 80 01 	or  %o2, %g1, %o2                              <== NOT EXECUTED
                                                     singly);         
                                                                      
          rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
4001d08c:	40 00 01 e5 	call  4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d090:	d4 27 bf fc 	st  %o2, [ %fp + -4 ]                          <== NOT EXECUTED
4001d094:	10 bf ff 88 	b  4001ceb4 <rtems_rfs_block_map_grow+0x140>   <== NOT EXECUTED
4001d098:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
                                                   &map->blocks[singly],
                                                   upping);           
        }                                                             
        else                                                          
        {                                                             
          rc = rtems_rfs_buffer_handle_request (fs,  &map->singly_buffer,
4001d09c:	82 05 60 08 	add  %l5, 8, %g1                               
4001d0a0:	83 28 60 02 	sll  %g1, 2, %g1                               
4001d0a4:	82 06 40 01 	add  %i1, %g1, %g1                             
4001d0a8:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
4001d0ac:	90 10 00 18 	mov  %i0, %o0                                  
4001d0b0:	92 10 00 12 	mov  %l2, %o1                                  
4001d0b4:	40 00 01 db 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001d0b8:	96 10 20 01 	mov  1, %o3                                    
4001d0bc:	10 bf ff 7e 	b  4001ceb4 <rtems_rfs_block_map_grow+0x140>   
4001d0c0:	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",
4001d0c4:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001d0c8:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001d0cc:	40 00 20 2c 	call  4002517c <printf>                        <== NOT EXECUTED
4001d0d0:	90 12 22 88 	or  %o0, 0x288, %o0	! 40037e88 <CSWTCH.2+0x98> <== NOT EXECUTED
            blocks, map->size.count);                                 
                                                                      
  if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
4001d0d4:	10 bf ff 30 	b  4001cd94 <rtems_rfs_block_map_grow+0x20>    <== NOT EXECUTED
4001d0d8:	c4 06 60 08 	ld  [ %i1 + 8 ], %g2                           <== NOT EXECUTED
              return rc;                                              
            }                                                         
          }                                                           
          else                                                        
          {                                                           
            rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001d0dc:	82 05 a0 08 	add  %l6, 8, %g1                               <== NOT EXECUTED
4001d0e0:	83 28 60 02 	sll  %g1, 2, %g1                               <== NOT EXECUTED
4001d0e4:	82 06 40 01 	add  %i1, %g1, %g1                             <== NOT EXECUTED
4001d0e8:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           <== NOT EXECUTED
4001d0ec:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001d0f0:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
4001d0f4:	40 00 01 cb 	call  4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d0f8:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
                                                  map->blocks[doubly], true);
            if (rc > 0)                                               
4001d0fc:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001d100:	24 bf ff b2 	ble,a   4001cfc8 <rtems_rfs_block_map_grow+0x254><== NOT EXECUTED
4001d104:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
            {                                                         
              rtems_rfs_group_bitmap_free (fs, false, singly_block);  
4001d108:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          <== NOT EXECUTED
4001d10c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001d110:	7f ff d8 50 	call  40013250 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001d114:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
              rtems_rfs_group_bitmap_free (fs, false, block);         
4001d118:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          <== NOT EXECUTED
4001d11c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001d120:	7f ff d8 4c 	call  40013250 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001d124:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001d128:	30 bf ff 20 	b,a   4001cda8 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
      *new_block = block;                                             
    map->last_data_block = block;                                     
    map->dirty = true;                                                
  }                                                                   
                                                                      
  return 0;                                                           
4001d12c:	ba 10 20 00 	clr  %i5                                       
}                                                                     
4001d130:	81 c7 e0 08 	ret                                            
4001d134:	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);           
4001d138:	d4 07 bf f8 	ld  [ %fp + -8 ], %o2                          <== NOT EXECUTED
4001d13c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001d140:	7f ff d8 44 	call  40013250 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001d144:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001d148:	30 bf ff 18 	b,a   4001cda8 <rtems_rfs_block_map_grow+0x34> <== NOT EXECUTED
                                                                      

4001c4e4 <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) {
4001c4e4:	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);
4001c4e8:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
4001c4ec:	94 10 20 00 	clr  %o2                                       
4001c4f0:	90 10 00 18 	mov  %i0, %o0                                  
4001c4f4:	7f ff da c8 	call  40013014 <rtems_rfs_group_bitmap_alloc>  
4001c4f8:	96 07 bf fc 	add  %fp, -4, %o3                              
  if (rc > 0)                                                         
4001c4fc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001c500:	04 80 00 04 	ble  4001c510 <rtems_rfs_block_map_indirect_alloc+0x2c><== ALWAYS TAKEN
4001c504:	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;                                                           
}                                                                     
4001c508:	81 c7 e0 08 	ret                                            
4001c50c:	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);
4001c510:	90 10 00 18 	mov  %i0, %o0                                  
4001c514:	92 10 00 1a 	mov  %i2, %o1                                  
4001c518:	40 00 04 c2 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001c51c:	96 10 20 00 	clr  %o3                                       
  if (rc > 0)                                                         
4001c520:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001c524:	04 80 00 08 	ble  4001c544 <rtems_rfs_block_map_indirect_alloc+0x60><== ALWAYS TAKEN
4001c528:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
  {                                                                   
    rtems_rfs_group_bitmap_free (fs, false, new_block);               
4001c52c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001c530:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001c534:	7f ff db 47 	call  40013250 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001c538:	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;                                                           
}                                                                     
4001c53c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c540:	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));
4001c544:	c2 06 a0 08 	ld  [ %i2 + 8 ], %g1                           
4001c548:	d4 06 20 08 	ld  [ %i0 + 8 ], %o2                           
4001c54c:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
4001c550:	40 00 22 8d 	call  40024f84 <memset>                        
4001c554:	92 10 20 ff 	mov  0xff, %o1                                 
  if (upping)                                                         
4001c558:	80 a7 20 00 	cmp  %i4, 0                                    
4001c55c:	12 80 00 08 	bne  4001c57c <rtems_rfs_block_map_indirect_alloc+0x98><== ALWAYS TAKEN
4001c560:	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);                               
4001c564:	84 10 20 01 	mov  1, %g2                                    
4001c568:	c4 2e 80 00 	stb  %g2, [ %i2 ]                              
  *block = new_block;                                                 
4001c56c:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
  map->last_map_block = new_block;                                    
4001c570:	c2 26 60 1c 	st  %g1, [ %i1 + 0x1c ]                        
  return 0;                                                           
4001c574:	10 bf ff e5 	b  4001c508 <rtems_rfs_block_map_indirect_alloc+0x24>
4001c578:	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))             
4001c57c:	90 10 20 00 	clr  %o0                                       
4001c580:	7f ff e2 c9 	call  400150a4 <rtems_rfs_trace>               
4001c584:	13 00 00 08 	sethi  %hi(0x2000), %o1                        
4001c588:	80 8a 20 ff 	btst  0xff, %o0                                
4001c58c:	32 80 00 24 	bne,a   4001c61c <rtems_rfs_block_map_indirect_alloc+0x138><== NEVER TAKEN
4001c590:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001c594:	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)  
{                                                                     
4001c598:	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]);         
4001c59c:	ba 10 20 01 	mov  1, %i5                                    
4001c5a0:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001c5a4:	c8 08 a0 24 	ldub  [ %g2 + 0x24 ], %g4                      
4001c5a8:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3                        
4001c5ac:	c8 28 c0 01 	stb  %g4, [ %g3 + %g1 ]                        
4001c5b0:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001c5b4:	c8 10 a0 24 	lduh  [ %g2 + 0x24 ], %g4                      
4001c5b8:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3                        
4001c5bc:	86 00 c0 01 	add  %g3, %g1, %g3                             
4001c5c0:	c8 28 e0 01 	stb  %g4, [ %g3 + 1 ]                          
4001c5c4:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001c5c8:	c8 00 a0 24 	ld  [ %g2 + 0x24 ], %g4                        
4001c5cc:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3                        
4001c5d0:	89 31 20 08 	srl  %g4, 8, %g4                               
4001c5d4:	86 00 c0 01 	add  %g3, %g1, %g3                             
4001c5d8:	c8 28 e0 02 	stb  %g4, [ %g3 + 2 ]                          
4001c5dc:	c6 06 a0 08 	ld  [ %i2 + 8 ], %g3                           
4001c5e0:	c8 00 a0 24 	ld  [ %g2 + 0x24 ], %g4                        
4001c5e4:	c6 00 e0 1c 	ld  [ %g3 + 0x1c ], %g3                        
4001c5e8:	84 00 a0 04 	add  %g2, 4, %g2                               
4001c5ec:	86 00 c0 01 	add  %g3, %g1, %g3                             
4001c5f0:	c8 28 e0 03 	stb  %g4, [ %g3 + 3 ]                          
4001c5f4:	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++)                      
4001c5f8:	80 a0 60 14 	cmp  %g1, 0x14                                 
4001c5fc:	12 bf ff e9 	bne  4001c5a0 <rtems_rfs_block_map_indirect_alloc+0xbc>
4001c600:	fa 2e 80 00 	stb  %i5, [ %i2 ]                              
      rtems_rfs_block_set_number (buffer, b, map->blocks[b]);         
    memset (map->blocks, 0, sizeof (map->blocks));                    
4001c604:	90 06 60 24 	add  %i1, 0x24, %o0                            
4001c608:	92 10 20 00 	clr  %o1                                       
4001c60c:	40 00 22 5e 	call  40024f84 <memset>                        
4001c610:	94 10 20 14 	mov  0x14, %o2                                 
  }                                                                   
  rtems_rfs_buffer_mark_dirty (buffer);                               
  *block = new_block;                                                 
4001c614:	10 bf ff d4 	b  4001c564 <rtems_rfs_block_map_indirect_alloc+0x80>
4001c618:	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",
4001c61c:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001c620:	40 00 22 d7 	call  4002517c <printf>                        <== NOT EXECUTED
4001c624:	90 12 22 00 	or  %o0, 0x200, %o0	! 40037e00 <CSWTCH.2+0x10> <== NOT EXECUTED
4001c628:	10 bf ff dc 	b  4001c598 <rtems_rfs_block_map_indirect_alloc+0xb4><== NOT EXECUTED
4001c62c:	84 10 00 19 	mov  %i1, %g2                                  <== NOT EXECUTED
                                                                      

4001c430 <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) {
4001c430:	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) ||                                                 
4001c434:	80 a7 20 00 	cmp  %i4, 0                                    
4001c438:	22 80 00 07 	be,a   4001c454 <rtems_rfs_block_map_indirect_shrink+0x24><== NEVER TAKEN
4001c43c:	b6 06 e0 08 	add  %i3, 8, %i3                               <== NOT EXECUTED
4001c440:	80 a7 20 05 	cmp  %i4, 5                                    
4001c444:	02 80 00 11 	be  4001c488 <rtems_rfs_block_map_indirect_shrink+0x58>
4001c448:	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;                                                         
4001c44c:	81 c7 e0 08 	ret                                            
4001c450:	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];         
4001c454:	b7 2e e0 02 	sll  %i3, 2, %i3                               <== NOT EXECUTED
4001c458:	b6 06 40 1b 	add  %i1, %i3, %i3                             <== NOT EXECUTED
4001c45c:	f4 06 e0 04 	ld  [ %i3 + 4 ], %i2                           <== NOT EXECUTED
    else                                                              
    {                                                                 
      /*                                                              
       * One less singly indirect block in the inode.                 
       */                                                             
      map->blocks[indirect] = 0;                                      
4001c460:	c0 26 e0 04 	clr  [ %i3 + 4 ]                               <== NOT EXECUTED
    }                                                                 
                                                                      
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
4001c464:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001c468:	92 10 20 00 	clr  %o1                                       
4001c46c:	7f ff db 79 	call  40013250 <rtems_rfs_group_bitmap_free>   
4001c470:	94 10 00 1a 	mov  %i2, %o2                                  
    if (rc > 0)                                                       
4001c474:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001c478:	24 80 00 02 	ble,a   4001c480 <rtems_rfs_block_map_indirect_shrink+0x50><== ALWAYS TAKEN
4001c47c:	f4 26 60 1c 	st  %i2, [ %i1 + 0x1c ]                        
                                                                      
    map->last_map_block = block_to_free;                              
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001c480:	81 c7 e0 08 	ret                                            
4001c484:	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) ||                                                 
4001c488:	12 bf ff f1 	bne  4001c44c <rtems_rfs_block_map_indirect_shrink+0x1c><== NEVER TAKEN
4001c48c:	84 10 20 00 	clr  %g2                                       
4001c490:	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];         
4001c494:	f4 06 60 24 	ld  [ %i1 + 0x24 ], %i2                        
4001c498:	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);      
4001c49c:	c8 08 40 00 	ldub  [ %g1 ], %g4                             
4001c4a0:	f6 08 60 01 	ldub  [ %g1 + 1 ], %i3                         
4001c4a4:	f8 08 60 03 	ldub  [ %g1 + 3 ], %i4                         
4001c4a8:	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,     
4001c4ac:	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);      
4001c4b0:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4001c4b4:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
4001c4b8:	bb 2f 60 08 	sll  %i5, 8, %i5                               
4001c4bc:	88 11 00 1b 	or  %g4, %i3, %g4                              
4001c4c0:	88 11 00 1c 	or  %g4, %i4, %g4                              
4001c4c4:	88 11 00 1d 	or  %g4, %i5, %g4                              
4001c4c8:	c8 20 e0 24 	st  %g4, [ %g3 + 0x24 ]                        
4001c4cc:	84 00 a0 04 	add  %g2, 4, %g2                               
    {                                                                 
      /*                                                              
       * Move to direct inode access.                                 
       */                                                             
      int b;                                                          
      for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                    
4001c4d0:	80 a0 a0 14 	cmp  %g2, 0x14                                 
4001c4d4:	12 bf ff f2 	bne  4001c49c <rtems_rfs_block_map_indirect_shrink+0x6c>
4001c4d8:	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);      
4001c4dc:	10 bf ff e3 	b  4001c468 <rtems_rfs_block_map_indirect_shrink+0x38>
4001c4e0:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      

4001c810 <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) {
4001c810:	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;                                                 
4001c814:	c0 2e 80 00 	clrb  [ %i2 ]                                  
  map->inode = NULL;                                                  
4001c818:	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;                                                    
4001c81c:	c0 26 a0 08 	clr  [ %i2 + 8 ]                               
  size->offset = 0;                                                   
4001c820:	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;                                                      
4001c824:	c0 26 a0 10 	clr  [ %i2 + 0x10 ]                            
  bpos->boff = 0;                                                     
4001c828:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            
  bpos->block = 0;                                                    
4001c82c:	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;                                              
4001c830:	c0 2e a0 38 	clrb  [ %i2 + 0x38 ]                           
  handle->bnum  = 0;                                                  
4001c834:	c0 26 a0 3c 	clr  [ %i2 + 0x3c ]                            
  handle->buffer = NULL;                                              
4001c838:	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;                                              
4001c83c:	c0 2e a0 44 	clrb  [ %i2 + 0x44 ]                           
  handle->bnum  = 0;                                                  
4001c840:	c0 26 a0 48 	clr  [ %i2 + 0x48 ]                            
  handle->buffer = NULL;                                              
4001c844:	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);                              
4001c848:	90 10 00 18 	mov  %i0, %o0                                  
4001c84c:	92 10 00 19 	mov  %i1, %o1                                  
4001c850:	7f ff db 41 	call  40013554 <rtems_rfs_inode_load>          
4001c854:	ba 10 00 1a 	mov  %i2, %i5                                  
  if (rc > 0)                                                         
4001c858:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4001c85c:	14 80 00 3f 	bg  4001c958 <rtems_rfs_block_map_open+0x148>  <== NEVER TAKEN
4001c860:	88 10 00 1a 	mov  %i2, %g4                                  
4001c864:	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;                                                 
4001c868:	f2 26 a0 04 	st  %i1, [ %i2 + 4 ]                           
  for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)                        
4001c86c:	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]);      
4001c870:	b8 00 60 06 	add  %g1, 6, %i4                               
4001c874:	b9 2f 20 02 	sll  %i4, 2, %i4                               
4001c878:	b8 00 c0 1c 	add  %g3, %i4, %i4                             
4001c87c:	de 0f 20 04 	ldub  [ %i4 + 4 ], %o7                         
4001c880:	f4 0f 20 05 	ldub  [ %i4 + 5 ], %i2                         
4001c884:	f6 0f 20 07 	ldub  [ %i4 + 7 ], %i3                         
4001c888:	f8 0f 20 06 	ldub  [ %i4 + 6 ], %i4                         
4001c88c:	85 2b e0 18 	sll  %o7, 0x18, %g2                            
4001c890:	b5 2e a0 10 	sll  %i2, 0x10, %i2                            
4001c894:	b9 2f 20 08 	sll  %i4, 8, %i4                               
4001c898:	84 10 80 1a 	or  %g2, %i2, %g2                              
4001c89c:	84 10 80 1b 	or  %g2, %i3, %g2                              
4001c8a0:	84 10 80 1c 	or  %g2, %i4, %g2                              
    map->blocks[b] = rtems_rfs_inode_get_block (inode, b);            
4001c8a4:	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++)                        
4001c8a8:	82 00 60 01 	inc  %g1                                       
4001c8ac:	80 a0 60 05 	cmp  %g1, 5                                    
4001c8b0:	12 bf ff f0 	bne  4001c870 <rtems_rfs_block_map_open+0x60>  
4001c8b4:	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);             
4001c8b8:	c8 08 e0 0f 	ldub  [ %g3 + 0xf ], %g4                       
4001c8bc:	c2 08 e0 0c 	ldub  [ %g3 + 0xc ], %g1                       
4001c8c0:	f8 08 e0 0d 	ldub  [ %g3 + 0xd ], %i4                       
4001c8c4:	c4 08 e0 0e 	ldub  [ %g3 + 0xe ], %g2                       
4001c8c8:	b9 2f 20 10 	sll  %i4, 0x10, %i4                            
4001c8cc:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001c8d0:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4001c8d4:	82 10 40 1c 	or  %g1, %i4, %g1                              
4001c8d8:	82 10 40 04 	or  %g1, %g4, %g1                              
4001c8dc:	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);          
4001c8e0:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
  map->size.offset = rtems_rfs_inode_get_block_offset (inode);        
4001c8e4:	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);            
4001c8e8:	c2 08 e0 0a 	ldub  [ %g3 + 0xa ], %g1                       
4001c8ec:	83 28 60 08 	sll  %g1, 8, %g1                               
4001c8f0:	82 10 80 01 	or  %g2, %g1, %g1                              
4001c8f4:	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);          
4001c8f8:	c8 08 e0 33 	ldub  [ %g3 + 0x33 ], %g4                      
4001c8fc:	c2 08 e0 30 	ldub  [ %g3 + 0x30 ], %g1                      
4001c900:	f8 08 e0 31 	ldub  [ %g3 + 0x31 ], %i4                      
4001c904:	c4 08 e0 32 	ldub  [ %g3 + 0x32 ], %g2                      
4001c908:	b9 2f 20 10 	sll  %i4, 0x10, %i4                            
4001c90c:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001c910:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4001c914:	82 10 40 1c 	or  %g1, %i4, %g1                              
4001c918:	82 10 40 04 	or  %g1, %g4, %g1                              
4001c91c:	82 10 40 02 	or  %g1, %g2, %g1                              
  map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);   
4001c920:	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);         
4001c924:	c2 08 e0 34 	ldub  [ %g3 + 0x34 ], %g1                      
4001c928:	c8 08 e0 37 	ldub  [ %g3 + 0x37 ], %g4                      
4001c92c:	c4 08 e0 36 	ldub  [ %g3 + 0x36 ], %g2                      
4001c930:	f8 08 e0 35 	ldub  [ %g3 + 0x35 ], %i4                      
4001c934:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4001c938:	87 2f 20 10 	sll  %i4, 0x10, %g3                            
4001c93c:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001c940:	82 10 40 03 	or  %g1, %g3, %g1                              
4001c944:	82 10 40 04 	or  %g1, %g4, %g1                              
4001c948:	82 10 40 02 	or  %g1, %g2, %g1                              
  map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 
4001c94c:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
                                                                      
  rc = rtems_rfs_inode_unload (fs, inode, false);                     
4001c950:	7f ff db 65 	call  400136e4 <rtems_rfs_inode_unload>        
4001c954:	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);                       
4001c958:	92 06 a0 38 	add  %i2, 0x38, %o1                            <== NOT EXECUTED
4001c95c:	40 00 03 37 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001c960:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001c964:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001c968:	c0 2e a0 38 	clrb  [ %i2 + 0x38 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001c96c:	c0 26 a0 3c 	clr  [ %i2 + 0x3c ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001c970:	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);                       
4001c974:	92 06 a0 44 	add  %i2, 0x44, %o1                            <== NOT EXECUTED
4001c978:	40 00 03 30 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001c97c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001c980:	c0 2e a0 44 	clrb  [ %i2 + 0x44 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001c984:	c0 26 a0 48 	clr  [ %i2 + 0x48 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001c988:	c0 26 a0 4c 	clr  [ %i2 + 0x4c ]                            <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
4001c98c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001c990:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001d14c <rtems_rfs_block_map_shrink>: int rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, size_t blocks) {
4001d14c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))             
4001d150:	90 10 20 00 	clr  %o0                                       
4001d154:	13 00 00 10 	sethi  %hi(0x4000), %o1                        
4001d158:	7f ff df d3 	call  400150a4 <rtems_rfs_trace>               
4001d15c:	b6 10 00 18 	mov  %i0, %i3                                  
4001d160:	80 8a 20 ff 	btst  0xff, %o0                                
4001d164:	32 80 00 b0 	bne,a   4001d424 <rtems_rfs_block_map_shrink+0x2d8><== NEVER TAKEN
4001d168:	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)                                           
4001d16c:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
4001d170:	80 a7 20 00 	cmp  %i4, 0                                    
4001d174:	02 80 00 a9 	be  4001d418 <rtems_rfs_block_map_shrink+0x2cc>
4001d178:	80 a6 80 1c 	cmp  %i2, %i4                                  
4001d17c:	38 80 00 02 	bgu,a   4001d184 <rtems_rfs_block_map_shrink+0x38><== NEVER TAKEN
4001d180:	b4 10 00 1c 	mov  %i4, %i2                                  <== NOT EXECUTED
    return 0;                                                         
                                                                      
  if (blocks > map->size.count)                                       
    blocks = map->size.count;                                         
                                                                      
  while (blocks)                                                      
4001d184:	80 a6 a0 00 	cmp  %i2, 0                                    
4001d188:	02 80 00 98 	be  4001d3e8 <rtems_rfs_block_map_shrink+0x29c><== NEVER TAKEN
4001d18c:	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,
4001d190:	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;                                                
4001d194:	10 80 00 14 	b  4001d1e4 <rtems_rfs_block_map_shrink+0x98>  
4001d198:	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];                             
4001d19c:	b9 2f 20 02 	sll  %i4, 2, %i4                               
4001d1a0:	b8 06 40 1c 	add  %i1, %i4, %i4                             
4001d1a4:	fa 07 20 04 	ld  [ %i4 + 4 ], %i5                           
      map->blocks[block] = 0;                                         
4001d1a8:	c0 27 20 04 	clr  [ %i4 + 4 ]                               
      {                                                               
        rc = EIO;                                                     
        break;                                                        
      }                                                               
    }                                                                 
    rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);      
4001d1ac:	90 10 00 1b 	mov  %i3, %o0                                  
4001d1b0:	92 10 20 00 	clr  %o1                                       
4001d1b4:	7f ff d8 27 	call  40013250 <rtems_rfs_group_bitmap_free>   
4001d1b8:	94 10 00 1d 	mov  %i5, %o2                                  
    if (rc > 0)                                                       
4001d1bc:	80 a2 20 00 	cmp  %o0, 0                                    
4001d1c0:	14 80 00 63 	bg  4001d34c <rtems_rfs_block_map_shrink+0x200><== NEVER TAKEN
4001d1c4:	b4 86 bf ff 	addcc  %i2, -1, %i2                            
      return rc;                                                      
    map->size.count--;                                                
4001d1c8:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           
    map->size.offset = 0;                                             
4001d1cc:	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--;                                                
4001d1d0:	b8 07 3f ff 	add  %i4, -1, %i4                              
    map->size.offset = 0;                                             
    map->last_data_block = block_to_free;                             
4001d1d4:	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--;                                                
4001d1d8:	f8 26 60 08 	st  %i4, [ %i1 + 8 ]                           
    return 0;                                                         
                                                                      
  if (blocks > map->size.count)                                       
    blocks = map->size.count;                                         
                                                                      
  while (blocks)                                                      
4001d1dc:	02 80 00 80 	be  4001d3dc <rtems_rfs_block_map_shrink+0x290>
4001d1e0:	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;                                      
4001d1e4:	ba 07 3f ff 	add  %i4, -1, %i5                              
                                                                      
    if (block < RTEMS_RFS_INODE_BLOCKS)                               
4001d1e8:	80 a7 60 04 	cmp  %i5, 4                                    
4001d1ec:	28 bf ff ec 	bleu,a   4001d19c <rtems_rfs_block_map_shrink+0x50>
4001d1f0:	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;                          
4001d1f4:	f0 06 e0 34 	ld  [ %i3 + 0x34 ], %i0                        
4001d1f8:	90 10 00 1d 	mov  %i5, %o0                                  
4001d1fc:	40 00 51 76 	call  400317d4 <.urem>                         
4001d200:	92 10 00 18 	mov  %i0, %o1                                  
      singly = block / fs->blocks_per_block;                          
4001d204:	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;                          
4001d208:	a0 10 00 08 	mov  %o0, %l0                                  
      singly = block / fs->blocks_per_block;                          
4001d20c:	7f ff 95 25 	call  400026a0 <.udiv>                         
4001d210:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      if (block < fs->block_map_singly_blocks)                        
4001d214:	c2 06 e0 38 	ld  [ %i3 + 0x38 ], %g1                        
4001d218:	80 a7 40 01 	cmp  %i5, %g1                                  
4001d21c:	0a 80 00 4e 	bcs  4001d354 <rtems_rfs_block_map_shrink+0x208><== ALWAYS TAKEN
4001d220:	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)                   
4001d224:	c2 06 e0 3c 	ld  [ %i3 + 0x3c ], %g1                        <== NOT EXECUTED
4001d228:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
4001d22c:	1a 80 00 6d 	bcc  4001d3e0 <rtems_rfs_block_map_shrink+0x294><== NOT EXECUTED
4001d230:	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;                
4001d234:	7f ff 95 1b 	call  400026a0 <.udiv>                         <== NOT EXECUTED
4001d238:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
        doubly_singly = singly % fs->blocks_per_block;                
4001d23c:	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;                
4001d240:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
        doubly_singly = singly % fs->blocks_per_block;                
4001d244:	40 00 51 64 	call  400317d4 <.urem>                         <== NOT EXECUTED
4001d248:	90 10 00 14 	mov  %l4, %o0                                  <== NOT EXECUTED
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001d24c:	82 07 20 08 	add  %i4, 8, %g1                               <== NOT EXECUTED
4001d250:	83 28 60 02 	sll  %g1, 2, %g1                               <== NOT EXECUTED
4001d254:	82 06 40 01 	add  %i1, %g1, %g1                             <== NOT EXECUTED
4001d258:	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;                
4001d25c:	a8 10 00 08 	mov  %o0, %l4                                  <== NOT EXECUTED
                                                                      
        rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
4001d260:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
4001d264:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001d268:	40 00 01 6e 	call  4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d26c:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
                                              map->blocks[doubly], true);
        if (rc > 0)                                                   
4001d270:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001d274:	14 80 00 36 	bg  4001d34c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001d278:	85 2d 20 02 	sll  %l4, 2, %g2                               <== NOT EXECUTED
          return rc;                                                  
                                                                      
        singly = rtems_rfs_block_get_number (&map->doubly_buffer,     
4001d27c:	c2 06 60 4c 	ld  [ %i1 + 0x4c ], %g1                        <== NOT EXECUTED
4001d280:	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,
4001d284:	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,     
4001d288:	82 00 c0 02 	add  %g3, %g2, %g1                             <== NOT EXECUTED
4001d28c:	c6 08 c0 02 	ldub  [ %g3 + %g2 ], %g3                       <== NOT EXECUTED
4001d290:	ea 08 60 03 	ldub  [ %g1 + 3 ], %l5                         <== NOT EXECUTED
4001d294:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         <== NOT EXECUTED
4001d298:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
4001d29c:	87 28 e0 18 	sll  %g3, 0x18, %g3                            <== NOT EXECUTED
4001d2a0:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
4001d2a4:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
4001d2a8:	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,
4001d2ac:	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,     
4001d2b0:	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,
4001d2b4:	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,     
4001d2b8:	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,
4001d2bc:	40 00 01 59 	call  4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
4001d2c0:	94 10 00 15 	mov  %l5, %o2                                  <== NOT EXECUTED
                                              singly, true);          
        if (rc > 0)                                                   
4001d2c4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001d2c8:	14 80 00 21 	bg  4001d34c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001d2cc:	85 2c 20 02 	sll  %l0, 2, %g2                               <== NOT EXECUTED
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001d2d0:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        <== NOT EXECUTED
4001d2d4:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        <== NOT EXECUTED
                                                    direct);          
                                                                      
        if (direct == 0)                                              
4001d2d8:	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,
4001d2dc:	82 00 c0 02 	add  %g3, %g2, %g1                             <== NOT EXECUTED
4001d2e0:	c6 08 c0 02 	ldub  [ %g3 + %g2 ], %g3                       <== NOT EXECUTED
4001d2e4:	fa 08 60 03 	ldub  [ %g1 + 3 ], %i5                         <== NOT EXECUTED
4001d2e8:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         <== NOT EXECUTED
4001d2ec:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         <== NOT EXECUTED
4001d2f0:	87 28 e0 18 	sll  %g3, 0x18, %g3                            <== NOT EXECUTED
4001d2f4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            <== NOT EXECUTED
4001d2f8:	ba 17 40 03 	or  %i5, %g3, %i5                              <== NOT EXECUTED
4001d2fc:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
4001d300:	ba 17 40 02 	or  %i5, %g2, %i5                              <== NOT EXECUTED
                                                    direct);          
                                                                      
        if (direct == 0)                                              
4001d304:	12 bf ff aa 	bne  4001d1ac <rtems_rfs_block_map_shrink+0x60><== NOT EXECUTED
4001d308:	ba 17 40 01 	or  %i5, %g1, %i5                              <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_group_bitmap_free (fs, false, singly);       
4001d30c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001d310:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001d314:	7f ff d7 cf 	call  40013250 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
4001d318:	94 10 00 15 	mov  %l5, %o2                                  <== NOT EXECUTED
          if (rc > 0)                                                 
4001d31c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001d320:	14 80 00 0b 	bg  4001d34c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
4001d324:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
            return rc;                                                
                                                                      
          map->last_map_block = singly;                               
4001d328:	ea 26 60 1c 	st  %l5, [ %i1 + 0x1c ]                        <== NOT EXECUTED
                                                                      
          rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
4001d32c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
4001d330:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
4001d334:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4001d338:	7f ff fc 3e 	call  4001c430 <rtems_rfs_block_map_indirect_shrink><== NOT EXECUTED
4001d33c:	98 10 00 14 	mov  %l4, %o4                                  <== NOT EXECUTED
                                                    doubly, doubly_singly);
          if (rc)                                                     
4001d340:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001d344:	22 bf ff 9b 	be,a   4001d1b0 <rtems_rfs_block_map_shrink+0x64><== NOT EXECUTED
4001d348:	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;                                                           
}                                                                     
4001d34c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d350:	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,
4001d354:	82 02 20 08 	add  %o0, 8, %g1                               
4001d358:	83 28 60 02 	sll  %g1, 2, %g1                               
4001d35c:	82 06 40 01 	add  %i1, %g1, %g1                             
4001d360:	d4 00 60 04 	ld  [ %g1 + 4 ], %o2                           
4001d364:	90 10 00 1b 	mov  %i3, %o0                                  
4001d368:	92 10 00 12 	mov  %l2, %o1                                  
4001d36c:	40 00 01 2d 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001d370:	96 10 20 01 	mov  1, %o3                                    
                                              map->blocks[singly], true);
        if (rc > 0)                                                   
4001d374:	80 a2 20 00 	cmp  %o0, 0                                    
4001d378:	14 bf ff f5 	bg  4001d34c <rtems_rfs_block_map_shrink+0x200><== NEVER TAKEN
4001d37c:	85 2c 20 02 	sll  %l0, 2, %g2                               
          return rc;                                                  
                                                                      
        block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
4001d380:	c2 06 60 40 	ld  [ %i1 + 0x40 ], %g1                        
4001d384:	c6 00 60 1c 	ld  [ %g1 + 0x1c ], %g3                        
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001d388:	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,
4001d38c:	82 00 c0 02 	add  %g3, %g2, %g1                             
4001d390:	c6 08 c0 02 	ldub  [ %g3 + %g2 ], %g3                       
4001d394:	fa 08 60 03 	ldub  [ %g1 + 3 ], %i5                         
4001d398:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         
4001d39c:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         
4001d3a0:	87 28 e0 18 	sll  %g3, 0x18, %g3                            
4001d3a4:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
4001d3a8:	83 28 60 08 	sll  %g1, 8, %g1                               
4001d3ac:	ba 17 40 03 	or  %i5, %g3, %i5                              
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001d3b0:	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,
4001d3b4:	ba 17 40 02 	or  %i5, %g2, %i5                              
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001d3b8:	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,
4001d3bc:	ba 17 40 01 	or  %i5, %g1, %i5                              
                                                    direct);          
                                                                      
        rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
4001d3c0:	96 10 00 14 	mov  %l4, %o3                                  
4001d3c4:	7f ff fc 1b 	call  4001c430 <rtems_rfs_block_map_indirect_shrink>
4001d3c8:	98 10 00 10 	mov  %l0, %o4                                  
                                                  singly, direct);    
        if (rc)                                                       
4001d3cc:	80 a2 20 00 	cmp  %o0, 0                                    
4001d3d0:	22 bf ff 78 	be,a   4001d1b0 <rtems_rfs_block_map_shrink+0x64><== ALWAYS TAKEN
4001d3d4:	90 10 00 1b 	mov  %i3, %o0                                  
4001d3d8:	30 bf ff dd 	b,a   4001d34c <rtems_rfs_block_map_shrink+0x200><== NOT EXECUTED
    map->last_data_block = block_to_free;                             
    map->dirty = true;                                                
    blocks--;                                                         
  }                                                                   
                                                                      
  if (map->size.count == 0)                                           
4001d3dc:	80 a7 20 00 	cmp  %i4, 0                                    
4001d3e0:	22 80 00 17 	be,a   4001d43c <rtems_rfs_block_map_shrink+0x2f0>
4001d3e4:	c0 26 60 1c 	clr  [ %i1 + 0x1c ]                            
  }                                                                   
                                                                      
  /*                                                                  
   * Keep the position inside the map.                                
   */                                                                 
  if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))          
4001d3e8:	c4 06 60 10 	ld  [ %i1 + 0x10 ], %g2                        
4001d3ec:	80 a0 80 1c 	cmp  %g2, %i4                                  
4001d3f0:	1a 80 00 14 	bcc  4001d440 <rtems_rfs_block_map_shrink+0x2f4><== NEVER TAKEN
4001d3f4:	82 07 3f ff 	add  %i4, -1, %g1                              
4001d3f8:	80 a0 40 02 	cmp  %g1, %g2                                  
4001d3fc:	12 80 00 08 	bne  4001d41c <rtems_rfs_block_map_shrink+0x2d0><== NEVER TAKEN
4001d400:	90 10 20 00 	clr  %o0                                       
4001d404:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
4001d408:	c4 06 60 14 	ld  [ %i1 + 0x14 ], %g2                        
4001d40c:	80 a0 80 01 	cmp  %g2, %g1                                  
4001d410:	38 80 00 0e 	bgu,a   4001d448 <rtems_rfs_block_map_shrink+0x2fc><== ALWAYS TAKEN
4001d414:	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;                                                         
4001d418:	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;                                                           
}                                                                     
4001d41c:	81 c7 e0 08 	ret                                            
4001d420:	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",
4001d424:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001d428:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001d42c:	40 00 1f 54 	call  4002517c <printf>                        <== NOT EXECUTED
4001d430:	90 12 22 c0 	or  %o0, 0x2c0, %o0	! 40037ec0 <CSWTCH.2+0xd0> <== NOT EXECUTED
            blocks, map->size.count);                                 
                                                                      
  if (map->size.count == 0)                                           
4001d434:	10 bf ff 4f 	b  4001d170 <rtems_rfs_block_map_shrink+0x24>  <== NOT EXECUTED
4001d438:	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;                                         
4001d43c:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
4001d440:	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);           
4001d444:	f8 26 60 10 	st  %i4, [ %i1 + 0x10 ]                        
4001d448:	c2 26 60 14 	st  %g1, [ %i1 + 0x14 ]                        
4001d44c:	80 a0 60 00 	cmp  %g1, 0                                    
4001d450:	02 bf ff f2 	be  4001d418 <rtems_rfs_block_map_shrink+0x2cc><== ALWAYS TAKEN
4001d454:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            
4001d458:	b8 07 3f ff 	add  %i4, -1, %i4                              <== NOT EXECUTED
                                                                      
  return 0;                                                           
4001d45c:	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);           
4001d460:	f8 26 60 10 	st  %i4, [ %i1 + 0x10 ]                        <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
4001d464:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d468:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
                                                                      

400236b8 <rtems_rfs_buffer_bdbuf_release>: int rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer, bool modified) {
400236b8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc;                                               
  int               rc = 0;                                           
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
400236bc:	90 10 20 00 	clr  %o0                                       
400236c0:	7f ff c6 79 	call  400150a4 <rtems_rfs_trace>               
400236c4:	92 10 20 40 	mov  0x40, %o1                                 
400236c8:	80 8a 20 ff 	btst  0xff, %o0                                
400236cc:	02 80 00 0b 	be  400236f8 <rtems_rfs_buffer_bdbuf_release+0x40><== ALWAYS TAKEN
400236d0:	80 a6 60 00 	cmp  %i1, 0                                    
    printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
400236d4:	d2 06 20 34 	ld  [ %i0 + 0x34 ], %o1                        <== NOT EXECUTED
400236d8:	12 80 00 18 	bne  40023738 <rtems_rfs_buffer_bdbuf_release+0x80><== NOT EXECUTED
400236dc:	d4 06 20 18 	ld  [ %i0 + 0x18 ], %o2                        <== NOT EXECUTED
400236e0:	17 10 00 e3 	sethi  %hi(0x40038c00), %o3                    <== NOT EXECUTED
400236e4:	96 12 e2 50 	or  %o3, 0x250, %o3	! 40038e50 <CSWTCH.2+0x1060><== NOT EXECUTED
400236e8:	11 10 00 e5 	sethi  %hi(0x40039400), %o0                    <== NOT EXECUTED
400236ec:	40 00 06 a4 	call  4002517c <printf>                        <== NOT EXECUTED
400236f0:	90 12 21 30 	or  %o0, 0x130, %o0	! 40039530 <rtems_rfs_rtems_file_handlers+0x3c><== NOT EXECUTED
            ((intptr_t) buffer->user),                                
            buffer->block, modified ? "(modified)" : "");             
                                                                      
  if (modified)                                                       
400236f4:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
400236f8:	02 80 00 09 	be  4002371c <rtems_rfs_buffer_bdbuf_release+0x64>
400236fc:	90 10 00 18 	mov  %i0, %o0                                  
    sc = rtems_bdbuf_release_modified (buffer);                       
40023700:	7f ff d0 29 	call  400177a4 <rtems_bdbuf_release_modified>  
40023704:	01 00 00 00 	nop                                            
int                                                                   
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,             
                                bool              modified)           
{                                                                     
  rtems_status_code sc;                                               
  int               rc = 0;                                           
40023708:	80 a0 00 08 	cmp  %g0, %o0                                  
4002370c:	b0 60 20 00 	subx  %g0, 0, %i0                              
#endif                                                                
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
40023710:	b0 0e 20 05 	and  %i0, 5, %i0                               
40023714:	81 c7 e0 08 	ret                                            
40023718:	81 e8 00 00 	restore                                        
            buffer->block, modified ? "(modified)" : "");             
                                                                      
  if (modified)                                                       
    sc = rtems_bdbuf_release_modified (buffer);                       
  else                                                                
    sc = rtems_bdbuf_release (buffer);                                
4002371c:	7f ff cf ea 	call  400176c4 <rtems_bdbuf_release>           
40023720:	01 00 00 00 	nop                                            
int                                                                   
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,             
                                bool              modified)           
{                                                                     
  rtems_status_code sc;                                               
  int               rc = 0;                                           
40023724:	80 a0 00 08 	cmp  %g0, %o0                                  
40023728:	b0 60 20 00 	subx  %g0, 0, %i0                              
#endif                                                                
    rc = EIO;                                                         
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4002372c:	b0 0e 20 05 	and  %i0, 5, %i0                               
40023730:	81 c7 e0 08 	ret                                            
40023734:	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",
40023738:	17 10 00 e5 	sethi  %hi(0x40039400), %o3                    <== NOT EXECUTED
4002373c:	10 bf ff eb 	b  400236e8 <rtems_rfs_buffer_bdbuf_release+0x30><== NOT EXECUTED
40023740:	96 12 e1 20 	or  %o3, 0x120, %o3	! 40039520 <rtems_rfs_rtems_file_handlers+0x2c><== NOT EXECUTED
40023744:	40 02 39 e8 	call  400b1ee4 <__end+0x66194>                 <== NOT EXECUTED
40023748:	40 02 39 54 	call  400b1c98 <__end+0x65f48>                 <== NOT EXECUTED
4002374c:	40 02 39 48 	call  400b1c6c <__end+0x65f1c>                 <== NOT EXECUTED
40023750:	40 02 39 3c 	call  400b1c40 <__end+0x65ef0>                 <== NOT EXECUTED
40023754:	40 02 39 30 	call  400b1c14 <__end+0x65ec4>                 <== NOT EXECUTED
40023758:	40 02 39 28 	call  400b1bf8 <__end+0x65ea8>                 <== NOT EXECUTED
4002375c:	40 02 39 1c 	call  400b1bcc <__end+0x65e7c>                 <== NOT EXECUTED
40023760:	40 02 39 10 	call  400b1ba0 <__end+0x65e50>                 <== NOT EXECUTED
40023764:	40 02 39 04 	call  400b1b74 <__end+0x65e24>                 <== NOT EXECUTED
40023768:	40 02 38 fc 	call  400b1b58 <__end+0x65e08>                 <== NOT EXECUTED
4002376c:	40 02 38 f0 	call  400b1b2c <__end+0x65ddc>                 <== NOT EXECUTED
40023770:	40 02 38 e4 	call  400b1b00 <__end+0x65db0>                 <== NOT EXECUTED
40023774:	40 02 38 d8 	call  400b1ad4 <__end+0x65d84>                 <== NOT EXECUTED
                                                                      

4001def0 <rtems_rfs_buffer_close>: return 0; } int rtems_rfs_buffer_close (rtems_rfs_file_system* fs) {
4001def0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))                 
4001def4:	90 10 20 00 	clr  %o0                                       
4001def8:	92 10 20 10 	mov  0x10, %o1                                 
4001defc:	7f ff dc 6a 	call  400150a4 <rtems_rfs_trace>               
4001df00:	ba 10 00 18 	mov  %i0, %i5                                  
4001df04:	80 8a 20 ff 	btst  0xff, %o0                                
4001df08:	12 80 00 15 	bne  4001df5c <rtems_rfs_buffer_close+0x6c>    <== NEVER TAKEN
4001df0c:	11 10 00 e0 	sethi  %hi(0x40038000), %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));
4001df10:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4001df14:	90 10 00 1d 	mov  %i5, %o0                                  
4001df18:	7f ff ff ad 	call  4001ddcc <rtems_rfs_buffer_setblksize>   
4001df1c:	d2 00 60 20 	ld  [ %g1 + 0x20 ], %o1                        
                                                                      
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))     
4001df20:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001df24:	04 80 00 07 	ble  4001df40 <rtems_rfs_buffer_close+0x50>    <== ALWAYS TAKEN
4001df28:	90 10 20 00 	clr  %o0                                       
4001df2c:	7f ff dc 5e 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001df30:	92 10 20 10 	mov  0x10, %o1                                 <== NOT EXECUTED
4001df34:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001df38:	12 80 00 1f 	bne  4001dfb4 <rtems_rfs_buffer_close+0xc4>    <== NOT EXECUTED
4001df3c:	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)                                         
4001df40:	7f ff ac 58 	call  400090a0 <close>                         
4001df44:	d0 07 60 0c 	ld  [ %i5 + 0xc ], %o0                         
4001df48:	80 a2 20 00 	cmp  %o0, 0                                    
4001df4c:	06 80 00 08 	bl  4001df6c <rtems_rfs_buffer_close+0x7c>     <== NEVER TAKEN
4001df50:	01 00 00 00 	nop                                            
      printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n", 
              rc, strerror (rc));                                     
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001df54:	81 c7 e0 08 	ret                                            
4001df58:	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");                    
4001df5c:	40 00 1d 20 	call  400253dc <puts>                          <== NOT EXECUTED
4001df60:	90 12 23 98 	or  %o0, 0x398, %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));
4001df64:	10 bf ff ec 	b  4001df14 <rtems_rfs_buffer_close+0x24>      <== NOT EXECUTED
4001df68:	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;                                                       
4001df6c:	40 00 16 f3 	call  40023b38 <__errno>                       <== NOT EXECUTED
4001df70:	01 00 00 00 	nop                                            <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))               
4001df74:	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;                                                       
4001df78:	f0 02 00 00 	ld  [ %o0 ], %i0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))               
4001df7c:	7f ff dc 4a 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001df80:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001df84:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001df88:	02 80 00 09 	be  4001dfac <rtems_rfs_buffer_close+0xbc>     <== NOT EXECUTED
4001df8c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n", 
4001df90:	40 00 20 c5 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001df94:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001df98:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001df9c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001dfa0:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001dfa4:	40 00 1c 76 	call  4002517c <printf>                        <== NOT EXECUTED
4001dfa8:	90 12 20 00 	mov  %o0, %o0	! 40038400 <CSWTCH.2+0x610>      <== NOT EXECUTED
              rc, strerror (rc));                                     
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001dfac:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001dfb0:	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",
4001dfb4:	40 00 20 bc 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001dfb8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001dfbc:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001dfc0:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001dfc4:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001dfc8:	40 00 1c 6d 	call  4002517c <printf>                        <== NOT EXECUTED
4001dfcc:	90 12 23 c0 	or  %o0, 0x3c0, %o0	! 400383c0 <CSWTCH.2+0x5d0><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  if (close (fs->device) < 0)                                         
4001dfd0:	7f ff ac 34 	call  400090a0 <close>                         <== NOT EXECUTED
4001dfd4:	d0 07 60 0c 	ld  [ %i5 + 0xc ], %o0                         <== NOT EXECUTED
4001dfd8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001dfdc:	16 bf ff f4 	bge  4001dfac <rtems_rfs_buffer_close+0xbc>    <== NOT EXECUTED
4001dfe0:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001dfe4:	30 bf ff e2 	b,a   4001df6c <rtems_rfs_buffer_close+0x7c>   <== NOT EXECUTED
                                                                      

4001d638 <rtems_rfs_buffer_handle_release>: } int rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* handle) {
4001d638:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_buffer_handle_has_block (handle))                     
4001d63c:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4001d640:	80 a0 60 00 	cmp  %g1, 0                                    
4001d644:	02 80 00 13 	be  4001d690 <rtems_rfs_buffer_handle_release+0x58>
4001d648:	b8 10 20 00 	clr  %i4                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))      
4001d64c:	90 10 20 00 	clr  %o0                                       
4001d650:	7f ff de 95 	call  400150a4 <rtems_rfs_trace>               
4001d654:	92 10 22 00 	mov  0x200, %o1                                
4001d658:	80 8a 20 ff 	btst  0xff, %o0                                
4001d65c:	32 80 00 0f 	bne,a   4001d698 <rtems_rfs_buffer_handle_release+0x60><== NEVER TAKEN
4001d660:	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)                           
4001d664:	d0 06 60 08 	ld  [ %i1 + 8 ], %o0                           
4001d668:	fa 02 20 30 	ld  [ %o0 + 0x30 ], %i5                        
4001d66c:	80 a7 60 00 	cmp  %i5, 0                                    
4001d670:	04 80 00 05 	ble  4001d684 <rtems_rfs_buffer_handle_release+0x4c><== NEVER TAKEN
4001d674:	01 00 00 00 	nop                                            
      rtems_rfs_buffer_refs_down (handle);                            
4001d678:	ba 07 7f ff 	add  %i5, -1, %i5                              
4001d67c:	fa 22 20 30 	st  %i5, [ %o0 + 0x30 ]                        
                                                                      
    if (rtems_rfs_buffer_refs (handle) == 0)                          
4001d680:	80 a7 60 00 	cmp  %i5, 0                                    
4001d684:	02 80 00 15 	be  4001d6d8 <rtems_rfs_buffer_handle_release+0xa0>
4001d688:	b8 10 20 00 	clr  %i4                                       
          rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
          fs->release_count++;                                        
        }                                                             
      }                                                               
    }                                                                 
    handle->buffer = NULL;                                            
4001d68c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
4001d690:	81 c7 e0 08 	ret                                            
4001d694:	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",
4001d698:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001d69c:	12 80 00 28 	bne  4001d73c <rtems_rfs_buffer_handle_release+0x104><== NOT EXECUTED
4001d6a0:	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" : "");
4001d6a4:	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",
4001d6a8:	15 10 00 e3 	sethi  %hi(0x40038c00), %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" : "");
4001d6ac:	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",
4001d6b0:	80 a2 e0 00 	cmp  %o3, 0                                    <== NOT EXECUTED
4001d6b4:	12 80 00 28 	bne  4001d754 <rtems_rfs_buffer_handle_release+0x11c><== NOT EXECUTED
4001d6b8:	94 12 a2 50 	or  %o2, 0x250, %o2                            <== NOT EXECUTED
4001d6bc:	19 10 00 df 	sethi  %hi(0x40037c00), %o4                    <== NOT EXECUTED
4001d6c0:	98 13 23 90 	or  %o4, 0x390, %o4	! 40037f90 <CSWTCH.2+0x1a0><== NOT EXECUTED
4001d6c4:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001d6c8:	40 00 1e ad 	call  4002517c <printf>                        <== NOT EXECUTED
4001d6cc:	90 12 23 a0 	or  %o0, 0x3a0, %o0	! 40037fa0 <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)                           
4001d6d0:	10 bf ff e6 	b  4001d668 <rtems_rfs_buffer_handle_release+0x30><== NOT EXECUTED
4001d6d4:	d0 06 60 08 	ld  [ %i1 + 8 ], %o0                           <== NOT EXECUTED
4001d6d8:	7f ff f3 61 	call  4001a45c <_Chain_Extract>                
4001d6dc:	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--;                                            
4001d6e0:	c4 06 20 50 	ld  [ %i0 + 0x50 ], %g2                        
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
4001d6e4:	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--;                                            
4001d6e8:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
      if (rtems_rfs_fs_no_local_cache (fs))                           
4001d6ec:	80 88 60 02 	btst  2, %g1                                   
4001d6f0:	12 80 00 1c 	bne  4001d760 <rtems_rfs_buffer_handle_release+0x128>
4001d6f4:	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 +                                      
4001d6f8:	c6 06 20 70 	ld  [ %i0 + 0x70 ], %g3                        
4001d6fc:	c4 06 20 60 	ld  [ %i0 + 0x60 ], %g2                        
4001d700:	c2 06 20 40 	ld  [ %i0 + 0x40 ], %g1                        
4001d704:	84 00 c0 02 	add  %g3, %g2, %g2                             
4001d708:	80 a0 80 01 	cmp  %g2, %g1                                  
4001d70c:	1a 80 00 21 	bcc  4001d790 <rtems_rfs_buffer_handle_release+0x158>
4001d710:	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))                          
4001d714:	c2 0e 40 00 	ldub  [ %i1 ], %g1                             
4001d718:	80 a0 60 00 	cmp  %g1, 0                                    
4001d71c:	02 80 00 17 	be  4001d778 <rtems_rfs_buffer_handle_release+0x140>
4001d720:	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 );                               
4001d724:	7f ff c4 c2 	call  4000ea2c <_Chain_Append>                 
4001d728:	90 06 20 64 	add  %i0, 0x64, %o0                            
        {                                                             
          rtems_chain_append (&fs->release_modified,                  
                              rtems_rfs_buffer_link (handle));        
          fs->release_modified_count++;                               
4001d72c:	c2 06 20 70 	ld  [ %i0 + 0x70 ], %g1                        
4001d730:	82 00 60 01 	inc  %g1                                       
4001d734:	10 bf ff d6 	b  4001d68c <rtems_rfs_buffer_handle_release+0x54>
4001d738:	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" : "");
4001d73c:	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",
4001d740:	15 10 00 df 	sethi  %hi(0x40037c00), %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" : "");
4001d744:	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",
4001d748:	80 a2 e0 00 	cmp  %o3, 0                                    <== NOT EXECUTED
4001d74c:	02 bf ff dc 	be  4001d6bc <rtems_rfs_buffer_handle_release+0x84><== NOT EXECUTED
4001d750:	94 12 a3 88 	or  %o2, 0x388, %o2                            <== NOT EXECUTED
4001d754:	19 10 00 e3 	sethi  %hi(0x40038c00), %o4                    <== NOT EXECUTED
4001d758:	10 bf ff db 	b  4001d6c4 <rtems_rfs_buffer_handle_release+0x8c><== NOT EXECUTED
4001d75c:	98 13 22 50 	or  %o4, 0x250, %o4	! 40038e50 <CSWTCH.2+0x1060><== 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;                             
4001d760:	d0 06 60 08 	ld  [ %i1 + 8 ], %o0                           
        rc = rtems_rfs_buffer_io_release (handle->buffer,             
4001d764:	d2 0e 40 00 	ldub  [ %i1 ], %o1                             
4001d768:	40 00 17 d4 	call  400236b8 <rtems_rfs_buffer_bdbuf_release>
4001d76c:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
4001d770:	10 bf ff c7 	b  4001d68c <rtems_rfs_buffer_handle_release+0x54>
4001d774:	b8 10 00 08 	mov  %o0, %i4                                  
4001d778:	7f ff c4 ad 	call  4000ea2c <_Chain_Append>                 
4001d77c:	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++;                                        
4001d780:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
4001d784:	82 00 60 01 	inc  %g1                                       
4001d788:	10 bf ff c1 	b  4001d68c <rtems_rfs_buffer_handle_release+0x54>
4001d78c:	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))
4001d790:	90 10 20 00 	clr  %o0                                       
4001d794:	7f ff de 44 	call  400150a4 <rtems_rfs_trace>               
4001d798:	92 10 22 00 	mov  0x200, %o1                                
4001d79c:	80 8a 20 ff 	btst  0xff, %o0                                
4001d7a0:	32 80 00 19 	bne,a   4001d804 <rtems_rfs_buffer_handle_release+0x1cc><== NEVER TAKEN
4001d7a4:	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)         
4001d7a8:	c4 06 20 60 	ld  [ %i0 + 0x60 ], %g2                        
4001d7ac:	c2 06 20 70 	ld  [ %i0 + 0x70 ], %g1                        
4001d7b0:	80 a0 80 01 	cmp  %g2, %g1                                  
4001d7b4:	08 80 00 0d 	bleu  4001d7e8 <rtems_rfs_buffer_handle_release+0x1b0>
4001d7b8:	01 00 00 00 	nop                                            
 */                                                                   
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(               
  rtems_chain_control *the_chain                                      
)                                                                     
{                                                                     
  return _Chain_Get( the_chain );                                     
4001d7bc:	7f ff c4 a7 	call  4000ea58 <_Chain_Get>                    
4001d7c0:	90 06 20 54 	add  %i0, 0x54, %o0                            
          {                                                           
            buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
            fs->release_count--;                                      
4001d7c4:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        
            modified = false;                                         
4001d7c8:	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--;                                      
4001d7cc:	82 00 7f ff 	add  %g1, -1, %g1                              
4001d7d0:	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;                                   
4001d7d4:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
          rc = rtems_rfs_buffer_io_release (buffer, modified);        
4001d7d8:	40 00 17 b8 	call  400236b8 <rtems_rfs_buffer_bdbuf_release>
4001d7dc:	92 0a 60 01 	and  %o1, 1, %o1                               
4001d7e0:	10 bf ff cd 	b  4001d714 <rtems_rfs_buffer_handle_release+0xdc>
4001d7e4:	b8 10 00 08 	mov  %o0, %i4                                  
4001d7e8:	7f ff c4 9c 	call  4000ea58 <_Chain_Get>                    
4001d7ec:	90 06 20 64 	add  %i0, 0x64, %o0                            
          }                                                           
          else                                                        
          {                                                           
            buffer =                                                  
              (rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
            fs->release_modified_count--;                             
4001d7f0:	c2 06 20 70 	ld  [ %i0 + 0x70 ], %g1                        
            modified = true;                                          
4001d7f4:	92 10 20 01 	mov  1, %o1                                    
          }                                                           
          else                                                        
          {                                                           
            buffer =                                                  
              (rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
            fs->release_modified_count--;                             
4001d7f8:	82 00 7f ff 	add  %g1, -1, %g1                              
4001d7fc:	10 bf ff f6 	b  4001d7d4 <rtems_rfs_buffer_handle_release+0x19c>
4001d800:	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:"
4001d804:	c2 06 20 60 	ld  [ %i0 + 0x60 ], %g1                        <== NOT EXECUTED
4001d808:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001d80c:	92 02 40 01 	add  %o1, %g1, %o1                             <== NOT EXECUTED
4001d810:	40 00 1e 5b 	call  4002517c <printf>                        <== NOT EXECUTED
4001d814:	90 12 23 d8 	or  %o0, 0x3d8, %o0                            <== NOT EXECUTED
                    " %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
                                                                      
          if (fs->release_count > fs->release_modified_count)         
4001d818:	10 bf ff e5 	b  4001d7ac <rtems_rfs_buffer_handle_release+0x174><== NOT EXECUTED
4001d81c:	c4 06 20 60 	ld  [ %i0 + 0x60 ], %g2                        <== NOT EXECUTED
                                                                      

4001d820 <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) {
4001d820:	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))                     
4001d824:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4001d828:	80 a0 60 00 	cmp  %g1, 0                                    
4001d82c:	02 80 00 17 	be  4001d888 <rtems_rfs_buffer_handle_request+0x68>
4001d830:	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))           
4001d834:	80 a6 a0 00 	cmp  %i2, 0                                    
4001d838:	02 80 00 06 	be  4001d850 <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
4001d83c:	90 10 20 00 	clr  %o0                                       
4001d840:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
4001d844:	80 a0 40 1a 	cmp  %g1, %i2                                  
4001d848:	02 80 00 40 	be  4001d948 <rtems_rfs_buffer_handle_request+0x128>
4001d84c:	01 00 00 00 	nop                                            
      return 0;                                                       
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
4001d850:	7f ff de 15 	call  400150a4 <rtems_rfs_trace>               
4001d854:	92 10 21 00 	mov  0x100, %o1	! 100 <PROM_START+0x100>       
4001d858:	80 8a 20 ff 	btst  0xff, %o0                                
4001d85c:	32 80 00 3d 	bne,a   4001d950 <rtems_rfs_buffer_handle_request+0x130><== NEVER TAKEN
4001d860:	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);                
4001d864:	90 10 00 1d 	mov  %i5, %o0                                  
4001d868:	7f ff ff 74 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001d86c:	92 10 00 19 	mov  %i1, %o1                                  
    if (rc > 0)                                                       
4001d870:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001d874:	24 80 00 04 	ble,a   4001d884 <rtems_rfs_buffer_handle_request+0x64><== ALWAYS TAKEN
4001d878:	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;                                                           
}                                                                     
4001d87c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d880:	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;                                                 
4001d884:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
4001d888:	90 10 20 00 	clr  %o0                                       
4001d88c:	7f ff de 06 	call  400150a4 <rtems_rfs_trace>               
4001d890:	92 10 21 00 	mov  0x100, %o1                                
4001d894:	80 8a 20 ff 	btst  0xff, %o0                                
4001d898:	32 80 00 5b 	bne,a   4001da04 <rtems_rfs_buffer_handle_request+0x1e4><== NEVER TAKEN
4001d89c:	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)                                              
4001d8a0:	c2 07 60 50 	ld  [ %i5 + 0x50 ], %g1                        
4001d8a4:	80 a0 60 00 	cmp  %g1, 0                                    
4001d8a8:	12 80 00 44 	bne  4001d9b8 <rtems_rfs_buffer_handle_request+0x198>
4001d8ac:	90 07 60 44 	add  %i5, 0x44, %o0                            
4001d8b0:	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) &&                            
4001d8b4:	c4 07 40 00 	ld  [ %i5 ], %g2                               
4001d8b8:	80 88 a0 02 	btst  2, %g2                                   
4001d8bc:	02 80 00 2a 	be  4001d964 <rtems_rfs_buffer_handle_request+0x144>
4001d8c0:	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))                    
4001d8c4:	02 80 00 65 	be  4001da58 <rtems_rfs_buffer_handle_request+0x238><== ALWAYS TAKEN
4001d8c8:	90 10 00 1d 	mov  %i5, %o0                                  
  }                                                                   
                                                                      
  /*                                                                  
   * Increase the reference count of the buffer.                      
   */                                                                 
  rtems_rfs_buffer_refs_up (handle);                                  
4001d8cc:	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 );                               
4001d8d0:	92 10 00 01 	mov  %g1, %o1                                  
4001d8d4:	84 00 a0 01 	inc  %g2                                       
4001d8d8:	90 07 60 44 	add  %i5, 0x44, %o0                            
4001d8dc:	7f ff c4 54 	call  4000ea2c <_Chain_Append>                 
4001d8e0:	c4 20 60 30 	st  %g2, [ %g1 + 0x30 ]                        
  rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));  
  fs->buffers_count++;                                                
4001d8e4:	c4 07 60 50 	ld  [ %i5 + 0x50 ], %g2                        
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
4001d8e8:	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++;                                                
4001d8ec:	84 00 a0 01 	inc  %g2                                       
4001d8f0:	c4 27 60 50 	st  %g2, [ %i5 + 0x50 ]                        
                                                                      
  handle->buffer->user = (void*) ((intptr_t) block);                  
4001d8f4:	f4 20 60 34 	st  %i2, [ %g1 + 0x34 ]                        
  handle->bnum = block;                                               
4001d8f8:	f4 26 60 04 	st  %i2, [ %i1 + 4 ]                           
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))        
4001d8fc:	90 10 20 00 	clr  %o0                                       
4001d900:	7f ff dd e9 	call  400150a4 <rtems_rfs_trace>               
4001d904:	92 10 21 00 	mov  0x100, %o1                                
4001d908:	80 8a 20 ff 	btst  0xff, %o0                                
4001d90c:	02 80 00 0f 	be  4001d948 <rtems_rfs_buffer_handle_request+0x128><== ALWAYS TAKEN
4001d910:	80 a6 e0 00 	cmp  %i3, 0                                    
    printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
4001d914:	02 80 00 41 	be  4001da18 <rtems_rfs_buffer_handle_request+0x1f8><== NOT EXECUTED
4001d918:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           <== NOT EXECUTED
            block, read ? "read" : "get", handle->buffer->block,      
            handle->buffer->references);                              
                                                                      
  return 0;                                                           
4001d91c:	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",
4001d920:	d6 00 60 18 	ld  [ %g1 + 0x18 ], %o3                        <== NOT EXECUTED
4001d924:	d8 00 60 30 	ld  [ %g1 + 0x30 ], %o4                        <== NOT EXECUTED
4001d928:	15 10 00 dd 	sethi  %hi(0x40037400), %o2                    <== NOT EXECUTED
4001d92c:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001d930:	94 12 a0 d0 	or  %o2, 0xd0, %o2                             <== NOT EXECUTED
4001d934:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001d938:	40 00 1e 11 	call  4002517c <printf>                        <== NOT EXECUTED
4001d93c:	90 12 20 e8 	or  %o0, 0xe8, %o0                             <== NOT EXECUTED
4001d940:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d944:	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;                                                       
4001d948:	81 c7 e0 08 	ret                                            
4001d94c:	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",
4001d950:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001d954:	40 00 1e 0a 	call  4002517c <printf>                        <== NOT EXECUTED
4001d958:	90 12 20 18 	or  %o0, 0x18, %o0	! 40038018 <CSWTCH.2+0x228> <== NOT EXECUTED
              rtems_rfs_buffer_bnum (handle));                        
                                                                      
    rc = rtems_rfs_buffer_handle_release (fs, handle);                
4001d95c:	10 bf ff c3 	b  4001d868 <rtems_rfs_buffer_handle_request+0x48><== NOT EXECUTED
4001d960:	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) &&                            
4001d964:	32 bf ff db 	bne,a   4001d8d0 <rtems_rfs_buffer_handle_request+0xb0>
4001d968:	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)                                            
4001d96c:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
4001d970:	80 a0 60 00 	cmp  %g1, 0                                    
4001d974:	12 80 00 5a 	bne  4001dadc <rtems_rfs_buffer_handle_request+0x2bc>
4001d978:	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) &&                
4001d97c:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
4001d980:	80 a0 60 00 	cmp  %g1, 0                                    
4001d984:	02 80 00 35 	be  4001da58 <rtems_rfs_buffer_handle_request+0x238>
4001d988:	90 10 00 1d 	mov  %i5, %o0                                  
        fs->release_modified_count)                                   
    {                                                                 
      handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,   
4001d98c:	90 07 60 64 	add  %i5, 0x64, %o0                            
4001d990:	92 07 60 70 	add  %i5, 0x70, %o1                            
4001d994:	7f ff fe e1 	call  4001d518 <rtems_rfs_scan_chain>          
4001d998:	94 10 00 1a 	mov  %i2, %o2                                  
4001d99c:	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))                 
4001d9a0:	80 a2 20 00 	cmp  %o0, 0                                    
4001d9a4:	02 80 00 2c 	be  4001da54 <rtems_rfs_buffer_handle_request+0x234>
4001d9a8:	82 10 00 08 	mov  %o0, %g1                                  
        rtems_rfs_buffer_mark_dirty (handle);                         
4001d9ac:	84 10 20 01 	mov  1, %g2                                    
4001d9b0:	10 bf ff c7 	b  4001d8cc <rtems_rfs_buffer_handle_request+0xac>
4001d9b4:	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,              
4001d9b8:	92 07 60 50 	add  %i5, 0x50, %o1                            
4001d9bc:	7f ff fe d7 	call  4001d518 <rtems_rfs_scan_chain>          
4001d9c0:	94 10 00 1a 	mov  %i2, %o2                                  
                                           &fs->buffers_count,        
                                           block);                    
    if (rtems_rfs_buffer_handle_has_block (handle) &&                 
4001d9c4:	80 a2 20 00 	cmp  %o0, 0                                    
4001d9c8:	02 80 00 1f 	be  4001da44 <rtems_rfs_buffer_handle_request+0x224>
4001d9cc:	d0 26 60 08 	st  %o0, [ %i1 + 8 ]                           
        rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))      
4001d9d0:	90 10 20 00 	clr  %o0                                       
4001d9d4:	7f ff dd b4 	call  400150a4 <rtems_rfs_trace>               
4001d9d8:	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) &&                 
4001d9dc:	80 8a 20 ff 	btst  0xff, %o0                                
4001d9e0:	02 bf ff b5 	be  4001d8b4 <rtems_rfs_buffer_handle_request+0x94><== ALWAYS TAKEN
4001d9e4:	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", 
4001d9e8:	d2 00 60 30 	ld  [ %g1 + 0x30 ], %o1                        <== NOT EXECUTED
4001d9ec:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001d9f0:	92 02 60 01 	inc  %o1                                       <== NOT EXECUTED
4001d9f4:	40 00 1d e2 	call  4002517c <printf>                        <== NOT EXECUTED
4001d9f8:	90 12 20 78 	or  %o0, 0x78, %o0                             <== NOT EXECUTED
4001d9fc:	10 bf ff ae 	b  4001d8b4 <rtems_rfs_buffer_handle_request+0x94><== NOT EXECUTED
4001da00:	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); 
4001da04:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001da08:	40 00 1d dd 	call  4002517c <printf>                        <== NOT EXECUTED
4001da0c:	90 12 20 50 	or  %o0, 0x50, %o0	! 40038050 <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)                                              
4001da10:	10 bf ff a5 	b  4001d8a4 <rtems_rfs_buffer_handle_request+0x84><== NOT EXECUTED
4001da14:	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;                                                           
4001da18:	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",
4001da1c:	d6 00 60 18 	ld  [ %g1 + 0x18 ], %o3                        <== NOT EXECUTED
4001da20:	d8 00 60 30 	ld  [ %g1 + 0x30 ], %o4                        <== NOT EXECUTED
4001da24:	15 10 00 e0 	sethi  %hi(0x40038000), %o2                    <== NOT EXECUTED
4001da28:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001da2c:	94 12 a0 10 	or  %o2, 0x10, %o2                             <== NOT EXECUTED
4001da30:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001da34:	40 00 1d d2 	call  4002517c <printf>                        <== NOT EXECUTED
4001da38:	90 12 20 e8 	or  %o0, 0xe8, %o0                             <== NOT EXECUTED
4001da3c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001da40:	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) &&                            
4001da44:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001da48:	80 88 60 02 	btst  2, %g1                                   
4001da4c:	22 bf ff c9 	be,a   4001d970 <rtems_rfs_buffer_handle_request+0x150>
4001da50:	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);
4001da54:	90 10 00 1d 	mov  %i5, %o0                                  
4001da58:	92 10 00 1a 	mov  %i2, %o1                                  
4001da5c:	94 10 00 1b 	mov  %i3, %o2                                  
4001da60:	40 00 17 02 	call  40023668 <rtems_rfs_buffer_bdbuf_request>
4001da64:	96 06 60 08 	add  %i1, 8, %o3                               
                                                                      
    if (rc > 0)                                                       
4001da68:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001da6c:	04 80 00 16 	ble  4001dac4 <rtems_rfs_buffer_handle_request+0x2a4><== ALWAYS TAKEN
4001da70:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))    
4001da74:	7f ff dd 8c 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001da78:	92 10 21 00 	mov  0x100, %o1                                <== NOT EXECUTED
4001da7c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001da80:	02 bf ff 7f 	be  4001d87c <rtems_rfs_buffer_handle_request+0x5c><== NOT EXECUTED
4001da84:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
        printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
4001da88:	02 80 00 13 	be  4001dad4 <rtems_rfs_buffer_handle_request+0x2b4><== NOT EXECUTED
4001da8c:	3b 10 00 e0 	sethi  %hi(0x40038000), %i5                    <== NOT EXECUTED
4001da90:	3b 10 00 dd 	sethi  %hi(0x40037400), %i5                    <== NOT EXECUTED
4001da94:	ba 17 60 d0 	or  %i5, 0xd0, %i5	! 400374d0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001da98:	40 00 22 03 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001da9c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001daa0:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001daa4:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
4001daa8:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001daac:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001dab0:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4001dab4:	40 00 1d b2 	call  4002517c <printf>                        <== NOT EXECUTED
4001dab8:	90 12 20 b0 	or  %o0, 0xb0, %o0                             <== NOT EXECUTED
4001dabc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001dac0:	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));        
4001dac4:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
4001dac8:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
4001dacc:	10 bf ff 80 	b  4001d8cc <rtems_rfs_buffer_handle_request+0xac>
4001dad0:	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",
4001dad4:	10 bf ff f1 	b  4001da98 <rtems_rfs_buffer_handle_request+0x278><== NOT EXECUTED
4001dad8:	ba 17 60 10 	or  %i5, 0x10, %i5                             <== NOT EXECUTED
  {                                                                   
    /*                                                                
     * Check the local cache of released buffers.                     
     */                                                               
    if (fs->release_count)                                            
      handle->buffer = rtems_rfs_scan_chain (&fs->release,            
4001dadc:	92 07 60 60 	add  %i5, 0x60, %o1                            
4001dae0:	7f ff fe 8e 	call  4001d518 <rtems_rfs_scan_chain>          
4001dae4:	94 10 00 1a 	mov  %i2, %o2                                  
4001dae8:	d0 26 60 08 	st  %o0, [ %i1 + 8 ]                           
                                             &fs->release_count,      
                                             block);                  
                                                                      
    if (!rtems_rfs_buffer_handle_has_block (handle) &&                
4001daec:	80 a2 20 00 	cmp  %o0, 0                                    
4001daf0:	12 bf ff 77 	bne  4001d8cc <rtems_rfs_buffer_handle_request+0xac>
4001daf4:	82 10 00 08 	mov  %o0, %g1                                  
4001daf8:	10 bf ff a2 	b  4001d980 <rtems_rfs_buffer_handle_request+0x160>
4001dafc:	c2 07 60 70 	ld  [ %i5 + 0x70 ], %g1                        
                                                                      

4001db00 <rtems_rfs_buffer_open>: return rc; } int rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs) {
4001db00:	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))                  
4001db04:	90 10 20 00 	clr  %o0                                       
4001db08:	92 10 20 20 	mov  0x20, %o1                                 
4001db0c:	7f ff dd 66 	call  400150a4 <rtems_rfs_trace>               
4001db10:	ba 10 00 18 	mov  %i0, %i5                                  
4001db14:	80 8a 20 ff 	btst  0xff, %o0                                
4001db18:	12 80 00 1b 	bne  4001db84 <rtems_rfs_buffer_open+0x84>     <== NEVER TAKEN
4001db1c:	92 10 00 18 	mov  %i0, %o1                                  
    printf ("rtems-rfs: buffer-open: opening: %s\n", name);           
                                                                      
  fs->device = open (name, O_RDWR);                                   
4001db20:	90 10 00 1d 	mov  %i5, %o0                                  
4001db24:	7f ff b1 46 	call  4000a03c <open>                          
4001db28:	92 10 20 02 	mov  2, %o1                                    
  if (fs->device < 0)                                                 
4001db2c:	80 a2 20 00 	cmp  %o0, 0                                    
4001db30:	06 80 00 1e 	bl  4001dba8 <rtems_rfs_buffer_open+0xa8>      <== NEVER TAKEN
4001db34:	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)                                    
4001db38:	7f ff ad a6 	call  400091d0 <fstat>                         
4001db3c:	92 07 bf b8 	add  %fp, -72, %o1                             
4001db40:	80 a2 20 00 	cmp  %o0, 0                                    
4001db44:	06 80 00 3b 	bl  4001dc30 <rtems_rfs_buffer_open+0x130>     <== NEVER TAKEN
4001db48:	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))                                          
4001db4c:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
4001db50:	84 08 80 01 	and  %g2, %g1, %g2                             
4001db54:	03 00 00 18 	sethi  %hi(0x6000), %g1                        
4001db58:	80 a0 80 01 	cmp  %g2, %g1                                  
4001db5c:	22 80 00 1e 	be,a   4001dbd4 <rtems_rfs_buffer_open+0xd4>   <== ALWAYS TAKEN
4001db60:	d0 06 60 0c 	ld  [ %i1 + 0xc ], %o0                         
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
4001db64:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001db68:	7f ff dd 4f 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001db6c:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001db70:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001db74:	32 80 00 29 	bne,a   4001dc18 <rtems_rfs_buffer_open+0x118> <== NOT EXECUTED
4001db78:	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;                                                     
4001db7c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001db80:	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);           
4001db84:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001db88:	40 00 1d 7d 	call  4002517c <printf>                        <== NOT EXECUTED
4001db8c:	90 12 21 28 	or  %o0, 0x128, %o0	! 40038128 <CSWTCH.2+0x338><== NOT EXECUTED
                                                                      
  fs->device = open (name, O_RDWR);                                   
4001db90:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001db94:	7f ff b1 2a 	call  4000a03c <open>                          <== NOT EXECUTED
4001db98:	92 10 20 02 	mov  2, %o1                                    <== NOT EXECUTED
  if (fs->device < 0)                                                 
4001db9c:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001dba0:	16 bf ff e6 	bge  4001db38 <rtems_rfs_buffer_open+0x38>     <== NOT EXECUTED
4001dba4:	d0 26 60 0c 	st  %o0, [ %i1 + 0xc ]                         <== NOT EXECUTED
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
4001dba8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001dbac:	7f ff dd 3e 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001dbb0:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001dbb4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001dbb8:	02 bf ff f1 	be  4001db7c <rtems_rfs_buffer_open+0x7c>      <== NOT EXECUTED
4001dbbc:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: cannot open file\n");          
    return ENXIO;                                                     
4001dbc0:	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");          
4001dbc4:	40 00 1e 06 	call  400253dc <puts>                          <== NOT EXECUTED
4001dbc8:	90 12 21 50 	or  %o0, 0x150, %o0                            <== NOT EXECUTED
4001dbcc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001dbd0:	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);                   
4001dbd4:	94 06 60 10 	add  %i1, 0x10, %o2                            
4001dbd8:	13 10 01 10 	sethi  %hi(0x40044000), %o1                    
4001dbdc:	7f ff ad d3 	call  40009328 <ioctl>                         
4001dbe0:	92 12 62 09 	or  %o1, 0x209, %o1	! 40044209 <flashdisk_data+0x9751>
                                                                      
  /*                                                                  
   * 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)                                                        
4001dbe4:	80 a2 20 00 	cmp  %o0, 0                                    
4001dbe8:	02 80 00 23 	be  4001dc74 <rtems_rfs_buffer_open+0x174>     <== ALWAYS TAKEN
4001dbec:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
4001dbf0:	7f ff dd 2d 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001dbf4:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001dbf8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001dbfc:	02 bf ff e0 	be  4001db7c <rtems_rfs_buffer_open+0x7c>      <== NOT EXECUTED
4001dc00:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");    
    return ENXIO;                                                     
4001dc04:	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");    
4001dc08:	40 00 1d f5 	call  400253dc <puts>                          <== NOT EXECUTED
4001dc0c:	90 12 21 e8 	or  %o0, 0x1e8, %o0                            <== NOT EXECUTED
4001dc10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001dc14:	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);
4001dc18:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001dc1c:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001dc20:	40 00 1d 57 	call  4002517c <printf>                        <== NOT EXECUTED
4001dc24:	90 12 21 b0 	or  %o0, 0x1b0, %o0	! 400381b0 <CSWTCH.2+0x3c0><== NOT EXECUTED
4001dc28:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001dc2c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    return ENXIO;                                                     
  }                                                                   
                                                                      
  if (fstat (fs->device, &st) < 0)                                    
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))                
4001dc30:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001dc34:	7f ff dd 1c 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001dc38:	92 10 20 08 	mov  8, %o1                                    <== NOT EXECUTED
4001dc3c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001dc40:	02 bf ff cf 	be  4001db7c <rtems_rfs_buffer_open+0x7c>      <== NOT EXECUTED
4001dc44:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",       
              name, strerror (errno));                                
4001dc48:	40 00 17 bc 	call  40023b38 <__errno>                       <== NOT EXECUTED
4001dc4c:	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",       
4001dc50:	40 00 21 95 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001dc54:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
4001dc58:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001dc5c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001dc60:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001dc64:	40 00 1d 46 	call  4002517c <printf>                        <== NOT EXECUTED
4001dc68:	90 12 21 80 	or  %o0, 0x180, %o0	! 40038180 <CSWTCH.2+0x390><== NOT EXECUTED
4001dc6c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001dc70:	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))                  
4001dc74:	92 10 20 20 	mov  0x20, %o1                                 
4001dc78:	7f ff dd 0b 	call  400150a4 <rtems_rfs_trace>               
4001dc7c:	b0 10 20 00 	clr  %i0                                       
4001dc80:	80 8a 20 ff 	btst  0xff, %o0                                
4001dc84:	32 80 00 04 	bne,a   4001dc94 <rtems_rfs_buffer_open+0x194> <== NEVER TAKEN
4001dc88:	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;                                                           
}                                                                     
4001dc8c:	81 c7 e0 08 	ret                                            
4001dc90:	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",
4001dc94:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001dc98:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        <== NOT EXECUTED
4001dc9c:	d4 00 60 20 	ld  [ %g1 + 0x20 ], %o2                        <== NOT EXECUTED
4001dca0:	40 00 1d 37 	call  4002517c <printf>                        <== NOT EXECUTED
4001dca4:	90 12 22 18 	or  %o0, 0x218, %o0                            <== NOT EXECUTED
            rtems_rfs_fs_media_blocks (fs),                           
            rtems_rfs_fs_media_block_size (fs));                      
                                                                      
  return 0;                                                           
}                                                                     
4001dca8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001dcac:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001ddcc <rtems_rfs_buffer_setblksize>: return result; } int rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size) {
4001ddcc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))            
4001ddd0:	90 10 20 00 	clr  %o0                                       
  return result;                                                      
}                                                                     
                                                                      
int                                                                   
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)  
{                                                                     
4001ddd4:	f2 27 a0 48 	st  %i1, [ %fp + 0x48 ]                        
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))            
4001ddd8:	7f ff dc b3 	call  400150a4 <rtems_rfs_trace>               
4001dddc:	92 10 24 00 	mov  0x400, %o1                                
4001dde0:	80 8a 20 ff 	btst  0xff, %o0                                
4001dde4:	12 80 00 21 	bne  4001de68 <rtems_rfs_buffer_setblksize+0x9c><== NEVER TAKEN
4001dde8:	d2 07 a0 48 	ld  [ %fp + 0x48 ], %o1                        
    printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size); 
                                                                      
  rc = rtems_rfs_buffers_release (fs);                                
4001ddec:	7f ff ff d7 	call  4001dd48 <rtems_rfs_buffers_release>     
4001ddf0:	90 10 00 18 	mov  %i0, %o0                                  
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001ddf4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001ddf8:	04 80 00 07 	ble  4001de14 <rtems_rfs_buffer_setblksize+0x48><== ALWAYS TAKEN
4001ddfc:	90 10 20 00 	clr  %o0                                       
4001de00:	7f ff dc a9 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001de04:	92 10 24 00 	mov  0x400, %o1                                <== NOT EXECUTED
4001de08:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001de0c:	12 80 00 20 	bne  4001de8c <rtems_rfs_buffer_setblksize+0xc0><== NOT EXECUTED
4001de10:	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);                                    
4001de14:	7f ff ff a7 	call  4001dcb0 <rtems_rfs_buffer_sync>         
4001de18:	90 10 00 18 	mov  %i0, %o0                                  
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
4001de1c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001de20:	04 80 00 07 	ble  4001de3c <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
4001de24:	90 10 20 00 	clr  %o0                                       
4001de28:	7f ff dc 9f 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001de2c:	92 10 24 00 	mov  0x400, %o1                                <== NOT EXECUTED
4001de30:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001de34:	12 80 00 1e 	bne  4001deac <rtems_rfs_buffer_setblksize+0xe0><== NOT EXECUTED
4001de38:	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);     
4001de3c:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        
4001de40:	13 20 01 10 	sethi  %hi(0x80044000), %o1                    
4001de44:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
4001de48:	92 12 62 04 	or  %o1, 0x204, %o1                            
4001de4c:	9f c0 40 00 	call  %g1                                      
4001de50:	94 07 a0 48 	add  %fp, 0x48, %o2                            
  if (rc < 0)                                                         
4001de54:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001de58:	06 80 00 08 	bl  4001de78 <rtems_rfs_buffer_setblksize+0xac><== NEVER TAKEN
4001de5c:	01 00 00 00 	nop                                            
    rc = errno;                                                       
#endif                                                                
  return rc;                                                          
}                                                                     
4001de60:	81 c7 e0 08 	ret                                            
4001de64:	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); 
4001de68:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001de6c:	40 00 1c c4 	call  4002517c <printf>                        <== NOT EXECUTED
4001de70:	90 12 22 e8 	or  %o0, 0x2e8, %o0	! 400382e8 <CSWTCH.2+0x4f8><== NOT EXECUTED
4001de74:	30 bf ff de 	b,a   4001ddec <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;                                                       
4001de78:	40 00 17 30 	call  40023b38 <__errno>                       <== NOT EXECUTED
4001de7c:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001de80:	f0 02 00 00 	ld  [ %o0 ], %i0                               <== NOT EXECUTED
#endif                                                                
  return rc;                                                          
}                                                                     
4001de84:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001de88:	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",
4001de8c:	40 00 21 06 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001de90:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001de94:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001de98:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001de9c:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001dea0:	40 00 1c b7 	call  4002517c <printf>                        <== NOT EXECUTED
4001dea4:	90 12 23 18 	or  %o0, 0x318, %o0	! 40038318 <CSWTCH.2+0x528><== NOT EXECUTED
4001dea8:	30 bf ff db 	b,a   4001de14 <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",
4001deac:	40 00 20 fe 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001deb0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001deb4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001deb8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001debc:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001dec0:	40 00 1c af 	call  4002517c <printf>                        <== NOT EXECUTED
4001dec4:	90 12 23 58 	or  %o0, 0x358, %o0	! 40038358 <CSWTCH.2+0x568><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
#if RTEMS_RFS_USE_LIBBLOCK                                            
  rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);     
4001dec8:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
4001decc:	13 20 01 10 	sethi  %hi(0x80044000), %o1                    <== NOT EXECUTED
4001ded0:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        <== NOT EXECUTED
4001ded4:	92 12 62 04 	or  %o1, 0x204, %o1                            <== NOT EXECUTED
4001ded8:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4001dedc:	94 07 a0 48 	add  %fp, 0x48, %o2                            <== NOT EXECUTED
  if (rc < 0)                                                         
4001dee0:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001dee4:	16 bf ff e8 	bge  4001de84 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
4001dee8:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001deec:	30 bf ff e3 	b,a   4001de78 <rtems_rfs_buffer_setblksize+0xac><== NOT EXECUTED
                                                                      

4001dcb0 <rtems_rfs_buffer_sync>: return rc; } int rtems_rfs_buffer_sync (rtems_rfs_file_system* fs) {
4001dcb0:	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))                  
4001dcb4:	90 10 20 00 	clr  %o0                                       
4001dcb8:	92 10 20 20 	mov  0x20, %o1                                 
4001dcbc:	7f ff dc fa 	call  400150a4 <rtems_rfs_trace>               
4001dcc0:	ba 10 00 18 	mov  %i0, %i5                                  
4001dcc4:	80 8a 20 ff 	btst  0xff, %o0                                
4001dcc8:	12 80 00 1c 	bne  4001dd38 <rtems_rfs_buffer_sync+0x88>     <== NEVER TAKEN
4001dccc:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    
                                                                      
  /*                                                                  
   * @todo Split in the separate files for each type.                 
   */                                                                 
#if RTEMS_RFS_USE_LIBBLOCK                                            
  sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));                
4001dcd0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
4001dcd4:	7f ff e7 26 	call  4001796c <rtems_bdbuf_syncdev>           
4001dcd8:	b0 10 20 00 	clr  %i0                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
4001dcdc:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4001dce0:	12 80 00 06 	bne  4001dcf8 <rtems_rfs_buffer_sync+0x48>     <== NEVER TAKEN
4001dce4:	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);                                      
4001dce8:	7f ff 9e 0c 	call  40005518 <rtems_disk_release>            
4001dcec:	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;                                                      
}                                                                     
4001dcf0:	81 c7 e0 08 	ret                                            
4001dcf4:	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))                
4001dcf8:	92 10 20 20 	mov  0x20, %o1                                 <== NOT EXECUTED
4001dcfc:	7f ff dc ea 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001dd00:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4001dd04:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001dd08:	02 bf ff f8 	be  4001dce8 <rtems_rfs_buffer_sync+0x38>      <== NOT EXECUTED
4001dd0c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",     
4001dd10:	7f ff eb 40 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
4001dd14:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4001dd18:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4001dd1c:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001dd20:	40 00 1d 17 	call  4002517c <printf>                        <== NOT EXECUTED
4001dd24:	90 12 22 68 	or  %o0, 0x268, %o0	! 40038268 <CSWTCH.2+0x478><== NOT EXECUTED
              rtems_status_text (sc));                                
    result = EIO;                                                     
  }                                                                   
  rtems_disk_release (fs->disk);                                      
4001dd28:	7f ff 9d fc 	call  40005518 <rtems_disk_release>            <== NOT EXECUTED
4001dd2c:	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;                                                      
}                                                                     
4001dd30:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001dd34:	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");                     
4001dd38:	40 00 1d a9 	call  400253dc <puts>                          <== NOT EXECUTED
4001dd3c:	90 12 22 48 	or  %o0, 0x248, %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));                
4001dd40:	10 bf ff e5 	b  4001dcd4 <rtems_rfs_buffer_sync+0x24>       <== NOT EXECUTED
4001dd44:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
                                                                      

4001dd48 <rtems_rfs_buffers_release>: return rrc; } int rtems_rfs_buffers_release (rtems_rfs_file_system* fs) {
4001dd48:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rrc = 0;                                                        
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))               
4001dd4c:	90 10 20 00 	clr  %o0                                       
4001dd50:	7f ff dc d5 	call  400150a4 <rtems_rfs_trace>               
4001dd54:	92 10 20 40 	mov  0x40, %o1                                 
4001dd58:	80 8a 20 ff 	btst  0xff, %o0                                
4001dd5c:	32 80 00 15 	bne,a   4001ddb0 <rtems_rfs_buffers_release+0x68><== NEVER TAKEN
4001dd60:	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,                         
4001dd64:	92 06 20 60 	add  %i0, 0x60, %o1                            
4001dd68:	94 10 20 00 	clr  %o2                                       
4001dd6c:	7f ff fd c4 	call  4001d47c <rtems_rfs_release_chain>       
4001dd70:	90 06 20 54 	add  %i0, 0x54, %o0                            
4001dd74:	82 38 00 08 	xnor  %g0, %o0, %g1                            
4001dd78:	83 38 60 1f 	sra  %g1, 0x1f, %g1                            
4001dd7c:	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,                
4001dd80:	92 06 20 70 	add  %i0, 0x70, %o1                            
4001dd84:	ba 0f 40 01 	and  %i5, %g1, %i5                             
4001dd88:	90 06 20 64 	add  %i0, 0x64, %o0                            
4001dd8c:	7f ff fd bc 	call  4001d47c <rtems_rfs_release_chain>       
4001dd90:	94 10 20 01 	mov  1, %o2                                    
                                &fs->release_modified_count,          
                                true);                                
  if ((rc > 0) && (rrc == 0))                                         
4001dd94:	80 a7 60 00 	cmp  %i5, 0                                    
4001dd98:	12 80 00 04 	bne  4001dda8 <rtems_rfs_buffers_release+0x60> <== NEVER TAKEN
4001dd9c:	80 a2 20 00 	cmp  %o0, 0                                    
4001dda0:	34 80 00 02 	bg,a   4001dda8 <rtems_rfs_buffers_release+0x60><== NEVER TAKEN
4001dda4:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    rrc = rc;                                                         
                                                                      
  return rrc;                                                         
}                                                                     
4001dda8:	81 c7 e0 08 	ret                                            
4001ddac:	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 " "         
4001ddb0:	d4 06 20 60 	ld  [ %i0 + 0x60 ], %o2                        <== NOT EXECUTED
4001ddb4:	d6 06 20 70 	ld  [ %i0 + 0x70 ], %o3                        <== NOT EXECUTED
4001ddb8:	11 10 00 e0 	sethi  %hi(0x40038000), %o0                    <== NOT EXECUTED
4001ddbc:	40 00 1c f0 	call  4002517c <printf>                        <== NOT EXECUTED
4001ddc0:	90 12 22 98 	or  %o0, 0x298, %o0	! 40038298 <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,                         
4001ddc4:	10 bf ff e9 	b  4001dd68 <rtems_rfs_buffers_release+0x20>   <== NOT EXECUTED
4001ddc8:	92 06 20 60 	add  %i0, 0x60, %o1                            <== NOT EXECUTED
                                                                      

4001e524 <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) {
4001e524:	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))                
4001e528:	90 10 20 00 	clr  %o0                                       
4001e52c:	7f ff da de 	call  400150a4 <rtems_rfs_trace>               
4001e530:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    
4001e534:	80 8a 20 ff 	btst  0xff, %o0                                
4001e538:	32 80 00 7c 	bne,a   4001e728 <rtems_rfs_dir_add_entry+0x204><== NEVER TAKEN
4001e53c:	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);                      
4001e540:	90 10 00 18 	mov  %i0, %o0                                  
4001e544:	92 10 00 19 	mov  %i1, %o1                                  
4001e548:	7f ff f8 b2 	call  4001c810 <rtems_rfs_block_map_open>      
4001e54c:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001e550:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001e554:	04 80 00 04 	ble  4001e564 <rtems_rfs_dir_add_entry+0x40>   <== ALWAYS TAKEN
4001e558:	29 00 00 3f 	sethi  %hi(0xfc00), %l4                        
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001e55c:	81 c7 e0 08 	ret                                            
4001e560:	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;                                              
4001e564:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001e568:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001e56c:	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;                                                      
4001e570:	c0 27 bf 98 	clr  [ %fp + -104 ]                            
  bpos->boff = 0;                                                     
4001e574:	c0 27 bf 9c 	clr  [ %fp + -100 ]                            
  bpos->block = 0;                                                    
4001e578:	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)                       
4001e57c:	a8 15 23 ff 	or  %l4, 0x3ff, %l4                            
      {                                                               
        if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <                     
4001e580:	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);          
4001e584:	90 10 00 18 	mov  %i0, %o0                                  
4001e588:	92 07 bf b0 	add  %fp, -80, %o1                             
4001e58c:	94 07 bf 98 	add  %fp, -104, %o2                            
4001e590:	7f ff f9 75 	call  4001cb64 <rtems_rfs_block_map_find>      
4001e594:	96 07 bf 94 	add  %fp, -108, %o3                            
    if (rc > 0)                                                       
4001e598:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001e59c:	04 80 00 ae 	ble  4001e854 <rtems_rfs_dir_add_entry+0x330>  
4001e5a0:	80 a7 60 06 	cmp  %i5, 6                                    
    {                                                                 
      if (rc != ENXIO)                                                
4001e5a4:	12 80 00 c7 	bne  4001e8c0 <rtems_rfs_dir_add_entry+0x39c>  <== NEVER TAKEN
4001e5a8:	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);            
4001e5ac:	92 07 bf b0 	add  %fp, -80, %o1                             
4001e5b0:	94 10 20 01 	mov  1, %o2                                    
4001e5b4:	7f ff f9 f0 	call  4001cd74 <rtems_rfs_block_map_grow>      
4001e5b8:	96 07 bf 94 	add  %fp, -108, %o3                            
      if (rc > 0)                                                     
4001e5bc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001e5c0:	14 80 00 d1 	bg  4001e904 <rtems_rfs_dir_add_entry+0x3e0>   <== NEVER TAKEN
4001e5c4:	a0 10 20 00 	clr  %l0                                       
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
4001e5c8:	c2 07 bf 98 	ld  [ %fp + -104 ], %g1                        
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
4001e5cc:	d4 07 bf 94 	ld  [ %fp + -108 ], %o2                        
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
4001e5d0:	82 00 60 01 	inc  %g1                                       
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
4001e5d4:	a0 0c 20 ff 	and  %l0, 0xff, %l0                            
      }                                                               
                                                                      
      read = false;                                                   
    }                                                                 
                                                                      
    bpos.bno++;                                                       
4001e5d8:	c2 27 bf 98 	st  %g1, [ %fp + -104 ]                        
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);  
4001e5dc:	90 10 00 18 	mov  %i0, %o0                                  
4001e5e0:	92 07 bf a4 	add  %fp, -92, %o1                             
4001e5e4:	7f ff fc 8f 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001e5e8:	96 10 00 10 	mov  %l0, %o3                                  
    if (rc > 0)                                                       
4001e5ec:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001e5f0:	14 80 00 9b 	bg  4001e85c <rtems_rfs_dir_add_entry+0x338>   <== NEVER TAKEN
4001e5f4:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
      break;                                                          
    }                                                                 
                                                                      
    entry  = rtems_rfs_buffer_data (&buffer);                         
                                                                      
    if (!read)                                                        
4001e5f8:	80 a4 20 00 	cmp  %l0, 0                                    
4001e5fc:	02 80 00 5e 	be  4001e774 <rtems_rfs_dir_add_entry+0x250>   
4001e600:	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))
4001e604:	da 06 20 08 	ld  [ %i0 + 8 ], %o5                           
4001e608:	9e 83 7f f6 	addcc  %o5, -10, %o7                           
4001e60c:	02 bf ff df 	be  4001e588 <rtems_rfs_dir_add_entry+0x64>    <== NEVER TAKEN
4001e610:	90 10 00 18 	mov  %i0, %o0                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001e614:	e0 0f 60 08 	ldub  [ %i5 + 8 ], %l0                         
4001e618:	c8 0f 60 09 	ldub  [ %i5 + 9 ], %g4                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e61c:	e4 0f 40 00 	ldub  [ %i5 ], %l2                             
4001e620:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
4001e624:	c4 0f 60 03 	ldub  [ %i5 + 3 ], %g2                         
4001e628:	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);                   
4001e62c:	a1 2c 20 08 	sll  %l0, 8, %l0                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e630:	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);                   
4001e634:	a0 14 00 04 	or  %l0, %g4, %l0                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e638:	87 28 e0 08 	sll  %g3, 8, %g3                               
4001e63c:	83 28 60 10 	sll  %g1, 0x10, %g1                            
4001e640:	a4 14 80 03 	or  %l2, %g3, %l2                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001e644:	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);                      
4001e648:	a4 14 80 02 	or  %l2, %g2, %l2                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001e64c:	02 80 00 58 	be  4001e7ac <rtems_rfs_dir_add_entry+0x288>   
4001e650:	a4 14 80 01 	or  %l2, %g1, %l2                              
4001e654:	10 80 00 20 	b  4001e6d4 <rtems_rfs_dir_add_entry+0x1b0>    
4001e658:	a2 10 20 00 	clr  %l1                                       
        }                                                             
                                                                      
        break;                                                        
      }                                                               
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
4001e65c:	80 a4 00 01 	cmp  %l0, %g1                                  
4001e660:	1a 80 00 20 	bcc  4001e6e0 <rtems_rfs_dir_add_entry+0x1bc>  <== NEVER TAKEN
4001e664:	ba 07 40 10 	add  %i5, %l0, %i5                             
4001e668:	80 a4 a0 00 	cmp  %l2, 0                                    
4001e66c:	02 80 00 1e 	be  4001e6e4 <rtems_rfs_dir_add_entry+0x1c0>   <== NEVER TAKEN
4001e670:	90 10 20 00 	clr  %o0                                       
4001e674:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4001e678:	80 a0 40 12 	cmp  %g1, %l2                                  
4001e67c:	0a 80 00 1a 	bcs  4001e6e4 <rtems_rfs_dir_add_entry+0x1c0>  <== NEVER TAKEN
4001e680:	01 00 00 00 	nop                                            
        rtems_rfs_block_map_close (fs, &map);                         
        return EIO;                                                   
      }                                                               
                                                                      
      entry  += elength;                                              
      offset += elength;                                              
4001e684:	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))
4001e688:	80 a4 40 0f 	cmp  %l1, %o7                                  
4001e68c:	1a bf ff be 	bcc  4001e584 <rtems_rfs_dir_add_entry+0x60>   <== NEVER TAKEN
4001e690:	98 10 00 11 	mov  %l1, %o4                                  
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001e694:	e0 0f 60 08 	ldub  [ %i5 + 8 ], %l0                         
4001e698:	c8 0f 60 09 	ldub  [ %i5 + 9 ], %g4                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e69c:	e4 0f 40 00 	ldub  [ %i5 ], %l2                             
4001e6a0:	c6 0f 60 01 	ldub  [ %i5 + 1 ], %g3                         
4001e6a4:	c4 0f 60 03 	ldub  [ %i5 + 3 ], %g2                         
4001e6a8:	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);                   
4001e6ac:	a1 2c 20 08 	sll  %l0, 8, %l0                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e6b0:	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);                   
4001e6b4:	a0 14 00 04 	or  %l0, %g4, %l0                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001e6b8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001e6bc:	83 28 60 08 	sll  %g1, 8, %g1                               
4001e6c0:	a4 14 80 03 	or  %l2, %g3, %l2                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001e6c4:	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);                      
4001e6c8:	a4 14 80 02 	or  %l2, %g2, %l2                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001e6cc:	02 80 00 39 	be  4001e7b0 <rtems_rfs_dir_add_entry+0x28c>   
4001e6d0:	a4 14 80 01 	or  %l2, %g1, %l2                              
        }                                                             
                                                                      
        break;                                                        
      }                                                               
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
4001e6d4:	80 a4 20 0a 	cmp  %l0, 0xa                                  
4001e6d8:	34 bf ff e1 	bg,a   4001e65c <rtems_rfs_dir_add_entry+0x138><== ALWAYS TAKEN
4001e6dc:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))          
4001e6e0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e6e4:	7f ff da 70 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e6e8:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
4001e6ec:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e6f0:	32 80 00 27 	bne,a   4001e78c <rtems_rfs_dir_add_entry+0x268><== NOT EXECUTED
4001e6f4:	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);                       
4001e6f8:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
4001e6fc:	7f ff fb cf 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e700:	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);                         
4001e704:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001e708:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001e70c:	c0 27 bf a8 	clr  [ %fp + -88 ]                             <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001e710:	c0 27 bf ac 	clr  [ %fp + -84 ]                             <== NOT EXECUTED
4001e714:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001e718:	7f ff f8 9f 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001e71c:	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;                                                          
}                                                                     
4001e720:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e724:	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=",       
4001e728:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e72c:	40 00 1a 94 	call  4002517c <printf>                        <== NOT EXECUTED
4001e730:	90 12 23 08 	or  %o0, 0x308, %o0	! 40038708 <CSWTCH.2+0x918><== NOT EXECUTED
            rtems_rfs_inode_ino (dir));                               
    for (c = 0; c < length; c++)                                      
4001e734:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
4001e738:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
4001e73c:	02 80 00 08 	be  4001e75c <rtems_rfs_dir_add_entry+0x238>   <== NOT EXECUTED
4001e740:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
      printf ("%c", name[c]);                                         
4001e744:	d0 4e 80 01 	ldsb  [ %i2 + %g1 ], %o0                       <== NOT EXECUTED
4001e748:	40 00 1a f7 	call  40025324 <putchar>                       <== NOT EXECUTED
4001e74c:	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++)                                      
4001e750:	80 a7 40 1b 	cmp  %i5, %i3                                  <== NOT EXECUTED
4001e754:	12 bf ff fc 	bne  4001e744 <rtems_rfs_dir_add_entry+0x220>  <== NOT EXECUTED
4001e758:	82 10 00 1d 	mov  %i5, %g1                                  <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (", len=%zd\n", length);                                   
4001e75c:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001e760:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e764:	40 00 1a 86 	call  4002517c <printf>                        <== NOT EXECUTED
4001e768:	90 12 23 38 	or  %o0, 0x338, %o0	! 40038738 <CSWTCH.2+0x948><== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
4001e76c:	10 bf ff 76 	b  4001e544 <rtems_rfs_dir_add_entry+0x20>     <== NOT EXECUTED
4001e770:	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));             
4001e774:	d4 06 20 08 	ld  [ %i0 + 8 ], %o2                           
4001e778:	90 10 00 1d 	mov  %i5, %o0                                  
4001e77c:	40 00 1a 02 	call  40024f84 <memset>                        
4001e780:	92 10 20 ff 	mov  0xff, %o1                                 
                                                                      
    offset = 0;                                                       
                                                                      
    while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e784:	10 bf ff a1 	b  4001e608 <rtems_rfs_dir_add_entry+0xe4>     
4001e788:	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: "                        
4001e78c:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
4001e790:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001e794:	96 10 00 12 	mov  %l2, %o3                                  <== NOT EXECUTED
4001e798:	98 10 00 11 	mov  %l1, %o4                                  <== NOT EXECUTED
4001e79c:	40 00 1a 78 	call  4002517c <printf>                        <== NOT EXECUTED
4001e7a0:	90 12 20 20 	or  %o0, 0x20, %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);                       
4001e7a4:	10 bf ff d6 	b  4001e6fc <rtems_rfs_dir_add_entry+0x1d8>    <== NOT EXECUTED
4001e7a8:	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))
4001e7ac:	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))                  
4001e7b0:	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) <                     
4001e7b4:	80 a4 c0 0d 	cmp  %l3, %o5                                  
4001e7b8:	3a bf ff 74 	bcc,a   4001e588 <rtems_rfs_dir_add_entry+0x64><== NEVER TAKEN
4001e7bc:	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);                   
4001e7c0:	92 10 00 1b 	mov  %i3, %o1                                  
4001e7c4:	40 00 13 ed 	call  40023778 <rtems_rfs_dir_hash>            
4001e7c8:	90 10 00 1a 	mov  %i2, %o0                                  
          rtems_rfs_dir_set_entry_hash (entry, hash);                 
4001e7cc:	83 32 20 08 	srl  %o0, 8, %g1                               
4001e7d0:	c2 2f 60 06 	stb  %g1, [ %i5 + 6 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001e7d4:	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);                 
4001e7d8:	85 32 20 10 	srl  %o0, 0x10, %g2                            
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001e7dc:	c2 2f 60 01 	stb  %g1, [ %i5 + 1 ]                          
4001e7e0:	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);                 
4001e7e4:	87 32 20 18 	srl  %o0, 0x18, %g3                            
4001e7e8:	c4 2f 60 05 	stb  %g2, [ %i5 + 5 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001e7ec:	c2 2f 60 02 	stb  %g1, [ %i5 + 2 ]                          
4001e7f0:	85 37 20 18 	srl  %i4, 0x18, %g2                            
          rtems_rfs_dir_set_entry_length (entry,                      
4001e7f4:	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);                 
4001e7f8:	c6 2f 60 04 	stb  %g3, [ %i5 + 4 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001e7fc:	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);    
4001e800:	94 10 00 1b 	mov  %i3, %o2                                  
4001e804:	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);                 
4001e808:	d0 2f 60 07 	stb  %o0, [ %i5 + 7 ]                          
          rtems_rfs_dir_set_entry_ino (entry, ino);                   
4001e80c:	f8 2f 60 03 	stb  %i4, [ %i5 + 3 ]                          
          rtems_rfs_dir_set_entry_length (entry,                      
4001e810:	e6 2f 60 09 	stb  %l3, [ %i5 + 9 ]                          
4001e814:	c2 2f 60 08 	stb  %g1, [ %i5 + 8 ]                          
                                          RTEMS_RFS_DIR_ENTRY_SIZE + length);
          memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);    
4001e818:	40 00 19 4c 	call  40024d48 <memcpy>                        
4001e81c:	90 07 60 0a 	add  %i5, 0xa, %o0                             
          rtems_rfs_buffer_mark_dirty (&buffer);                      
4001e820:	82 10 20 01 	mov  1, %g1                                    
4001e824:	92 07 bf a4 	add  %fp, -92, %o1                             
4001e828:	90 10 00 18 	mov  %i0, %o0                                  
4001e82c:	7f ff fb 83 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001e830:	c2 2f bf a4 	stb  %g1, [ %fp + -92 ]                        
          rtems_rfs_buffer_handle_close (fs, &buffer);                
          rtems_rfs_block_map_close (fs, &map);                       
4001e834:	90 10 00 18 	mov  %i0, %o0                                  
  handle->dirty = false;                                              
4001e838:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001e83c:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001e840:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001e844:	92 07 bf b0 	add  %fp, -80, %o1                             
4001e848:	7f ff f8 53 	call  4001c994 <rtems_rfs_block_map_close>     
4001e84c:	ba 10 20 00 	clr  %i5                                       
4001e850:	30 bf ff 43 	b,a   4001e55c <rtems_rfs_dir_add_entry+0x38>  
  while (true)                                                        
  {                                                                   
    rtems_rfs_block_no block;                                         
    uint8_t*           entry;                                         
    int                offset;                                        
    bool               read = true;                                   
4001e854:	10 bf ff 5d 	b  4001e5c8 <rtems_rfs_dir_add_entry+0xa4>     
4001e858:	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))            
4001e85c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e860:	7f ff da 11 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e864:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
4001e868:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e86c:	22 80 00 0c 	be,a   4001e89c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001e870:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
        printf ("rtems-rfs: dir-add-entry: "                          
4001e874:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001e878:	40 00 1e 8b 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001e87c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001e880:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001e884:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001e888:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001e88c:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e890:	40 00 1a 3b 	call  4002517c <printf>                        <== NOT EXECUTED
4001e894:	90 12 23 d8 	or  %o0, 0x3d8, %o0	! 400387d8 <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);                       
4001e898:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
4001e89c:	7f ff fb 67 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001e8a0:	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);                               
4001e8a4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001e8a8:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001e8ac:	c0 27 bf a8 	clr  [ %fp + -88 ]                             <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001e8b0:	c0 27 bf ac 	clr  [ %fp + -84 ]                             <== NOT EXECUTED
4001e8b4:	7f ff f8 38 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001e8b8:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001e8bc:	30 bf ff 28 	b,a   4001e55c <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))          
4001e8c0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e8c4:	7f ff d9 f8 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e8c8:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
4001e8cc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e8d0:	22 bf ff f3 	be,a   4001e89c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001e8d4:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-add-entry: "                        
4001e8d8:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001e8dc:	40 00 1e 72 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001e8e0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001e8e4:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001e8e8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001e8ec:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001e8f0:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e8f4:	40 00 1a 22 	call  4002517c <printf>                        <== NOT EXECUTED
4001e8f8:	90 12 23 48 	or  %o0, 0x348, %o0	! 40038748 <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);                       
4001e8fc:	10 bf ff e8 	b  4001e89c <rtems_rfs_dir_add_entry+0x378>    <== NOT EXECUTED
4001e900:	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))          
4001e904:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e908:	7f ff d9 e7 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e90c:	13 08 00 00 	sethi  %hi(0x20000000), %o1                    <== NOT EXECUTED
4001e910:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e914:	22 bf ff e2 	be,a   4001e89c <rtems_rfs_dir_add_entry+0x378><== NOT EXECUTED
4001e918:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-add-entry: "                        
4001e91c:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001e920:	40 00 1e 61 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001e924:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001e928:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001e92c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001e930:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001e934:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e938:	40 00 1a 11 	call  4002517c <printf>                        <== NOT EXECUTED
4001e93c:	90 12 23 90 	or  %o0, 0x390, %o0	! 40038790 <CSWTCH.2+0x9a0><== NOT EXECUTED
4001e940:	10 bf ff d7 	b  4001e89c <rtems_rfs_dir_add_entry+0x378>    <== NOT EXECUTED
4001e944:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                                                                      

4001e948 <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) {
4001e948:	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))                
4001e94c:	90 10 20 00 	clr  %o0                                       
4001e950:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    
4001e954:	7f ff d9 d4 	call  400150a4 <rtems_rfs_trace>               
4001e958:	a2 10 00 18 	mov  %i0, %l1                                  
4001e95c:	80 8a 20 ff 	btst  0xff, %o0                                
4001e960:	12 80 00 0a 	bne  4001e988 <rtems_rfs_dir_del_entry+0x40>   <== NEVER TAKEN
4001e964:	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);                      
4001e968:	90 10 00 11 	mov  %l1, %o0                                  
4001e96c:	7f ff f7 a9 	call  4001c810 <rtems_rfs_block_map_open>      
4001e970:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001e974:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e978:	04 80 00 11 	ble  4001e9bc <rtems_rfs_dir_del_entry+0x74>   <== ALWAYS TAKEN
4001e97c:	90 10 00 11 	mov  %l1, %o0                                  
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001e980:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e984:	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",
4001e988:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001e98c:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001e990:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
4001e994:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001e998:	40 00 19 f9 	call  4002517c <printf>                        <== NOT EXECUTED
4001e99c:	90 12 20 68 	or  %o0, 0x68, %o0	! 40038868 <CSWTCH.2+0xa78> <== NOT EXECUTED
            rtems_rfs_inode_ino (dir), ino, offset);                  
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
4001e9a0:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001e9a4:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001e9a8:	7f ff f7 9a 	call  4001c810 <rtems_rfs_block_map_open>      <== NOT EXECUTED
4001e9ac:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
  if (rc > 0)                                                         
4001e9b0:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001e9b4:	14 bf ff f3 	bg  4001e980 <rtems_rfs_dir_del_entry+0x38>    <== NOT EXECUTED
4001e9b8:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);           
4001e9bc:	92 07 bf b0 	add  %fp, -80, %o1                             
4001e9c0:	94 10 20 00 	clr  %o2                                       
4001e9c4:	96 10 00 1b 	mov  %i3, %o3                                  
4001e9c8:	7f ff f8 c1 	call  4001cccc <rtems_rfs_block_map_seek>      
4001e9cc:	98 07 bf a0 	add  %fp, -96, %o4                             
  if (rc > 0)                                                         
4001e9d0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e9d4:	04 80 00 09 	ble  4001e9f8 <rtems_rfs_dir_del_entry+0xb0>   <== ALWAYS TAKEN
4001e9d8:	80 a6 20 06 	cmp  %i0, 6                                    
  {                                                                   
    if (rc == ENXIO)                                                  
4001e9dc:	22 80 00 02 	be,a   4001e9e4 <rtems_rfs_dir_del_entry+0x9c> <== NOT EXECUTED
4001e9e0:	b0 10 20 02 	mov  2, %i0                                    <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
4001e9e4:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001e9e8:	7f ff f7 eb 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001e9ec:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001e9f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e9f4:	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)                                                       
4001e9f8:	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)                       
4001e9fc:	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;                                              
4001ea00:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001ea04:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001ea08:	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)                                                       
4001ea0c:	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)                       
4001ea10:	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);  
4001ea14:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
4001ea18:	90 10 00 11 	mov  %l1, %o0                                  
4001ea1c:	92 07 bf a4 	add  %fp, -92, %o1                             
4001ea20:	7f ff fb 80 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001ea24:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
4001ea28:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001ea2c:	14 80 00 cc 	bg  4001ed5c <rtems_rfs_dir_del_entry+0x414>   <== NEVER TAKEN
4001ea30:	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)                                                       
4001ea34:	02 80 00 63 	be  4001ebc0 <rtems_rfs_dir_del_entry+0x278>   <== ALWAYS TAKEN
4001ea38:	ea 04 60 08 	ld  [ %l1 + 8 ], %l5                           
4001ea3c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
      eoffset = 0;                                                    
4001ea40:	a4 10 20 00 	clr  %l2                                       <== NOT EXECUTED
    else                                                              
      eoffset = offset % rtems_rfs_fs_block_size (fs);                
                                                                      
    entry = rtems_rfs_buffer_data (&buffer) + eoffset;                
4001ea44:	c2 07 bf ac 	ld  [ %fp + -84 ], %g1                         
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001ea48:	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;                
4001ea4c:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
                                                                      
    while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001ea50:	80 a3 c0 08 	cmp  %o7, %o0                                  
4001ea54:	08 80 00 33 	bleu  4001eb20 <rtems_rfs_dir_del_entry+0x1d8> <== NEVER TAKEN
4001ea58:	ba 00 40 08 	add  %g1, %o0, %i5                             
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001ea5c:	f8 0f 60 08 	ldub  [ %i5 + 8 ], %i4                         
4001ea60:	c8 0f 60 09 	ldub  [ %i5 + 9 ], %g4                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001ea64:	e0 0f 60 01 	ldub  [ %i5 + 1 ], %l0                         
4001ea68:	c6 0f 60 02 	ldub  [ %i5 + 2 ], %g3                         
4001ea6c:	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);                   
4001ea70:	b9 2f 20 08 	sll  %i4, 8, %i4                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001ea74:	c4 0f 60 03 	ldub  [ %i5 + 3 ], %g2                         
4001ea78:	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);                   
4001ea7c:	b8 17 00 04 	or  %i4, %g4, %i4                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001ea80:	87 28 e0 08 	sll  %g3, 8, %g3                               
4001ea84:	10 80 00 22 	b  4001eb0c <rtems_rfs_dir_del_entry+0x1c4>    
4001ea88:	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))              
4001ea8c:	80 a7 20 0a 	cmp  %i4, 0xa                                  
4001ea90:	04 80 00 33 	ble  4001eb5c <rtems_rfs_dir_del_entry+0x214>  <== NEVER TAKEN
4001ea94:	90 10 20 00 	clr  %o0                                       
4001ea98:	c2 04 60 1c 	ld  [ %l1 + 0x1c ], %g1                        
4001ea9c:	80 a7 00 01 	cmp  %i4, %g1                                  
4001eaa0:	1a 80 00 2f 	bcc  4001eb5c <rtems_rfs_dir_del_entry+0x214>  <== NEVER TAKEN
4001eaa4:	80 a4 20 00 	cmp  %l0, 0                                    
4001eaa8:	02 80 00 2d 	be  4001eb5c <rtems_rfs_dir_del_entry+0x214>   <== NEVER TAKEN
4001eaac:	01 00 00 00 	nop                                            
4001eab0:	c2 04 60 14 	ld  [ %l1 + 0x14 ], %g1                        
4001eab4:	80 a0 40 10 	cmp  %g1, %l0                                  
4001eab8:	0a 80 00 29 	bcs  4001eb5c <rtems_rfs_dir_del_entry+0x214>  <== NEVER TAKEN
4001eabc:	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))                     
4001eac0:	02 80 00 45 	be  4001ebd4 <rtems_rfs_dir_del_entry+0x28c>   <== ALWAYS TAKEN
4001eac4:	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)                                                    
4001eac8:	22 80 00 33 	be,a   4001eb94 <rtems_rfs_dir_del_entry+0x24c><== NOT EXECUTED
4001eacc:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      entry   += elength;                                             
      eoffset += elength;                                             
4001ead0:	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))
4001ead4:	80 a4 80 0f 	cmp  %l2, %o7                                  <== NOT EXECUTED
4001ead8:	1a 80 00 12 	bcc  4001eb20 <rtems_rfs_dir_del_entry+0x1d8>  <== NOT EXECUTED
4001eadc:	ba 07 40 1c 	add  %i5, %i4, %i5                             <== NOT EXECUTED
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001eae0:	f8 0f 60 08 	ldub  [ %i5 + 8 ], %i4                         <== NOT EXECUTED
4001eae4:	c8 0f 60 09 	ldub  [ %i5 + 9 ], %g4                         <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001eae8:	e0 0f 40 00 	ldub  [ %i5 ], %l0                             <== NOT EXECUTED
4001eaec:	c6 0f 60 01 	ldub  [ %i5 + 1 ], %g3                         <== NOT EXECUTED
4001eaf0:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         <== NOT EXECUTED
4001eaf4:	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);                   
4001eaf8:	b9 2f 20 08 	sll  %i4, 8, %i4                               <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001eafc:	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);                   
4001eb00:	b8 17 00 04 	or  %i4, %g4, %i4                              <== NOT EXECUTED
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001eb04:	87 28 e0 10 	sll  %g3, 0x10, %g3                            <== NOT EXECUTED
4001eb08:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
4001eb0c:	a0 14 00 03 	or  %l0, %g3, %l0                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001eb10:	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);                      
4001eb14:	a0 14 00 02 	or  %l0, %g2, %l0                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001eb18:	12 bf ff dd 	bne  4001ea8c <rtems_rfs_dir_del_entry+0x144>  <== ALWAYS TAKEN
4001eb1c:	a0 14 00 01 	or  %l0, %g1, %l0                              
                                                                      
      entry   += elength;                                             
      eoffset += elength;                                             
    }                                                                 
                                                                      
    if (rc == 0)                                                      
4001eb20:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
4001eb24:	12 80 00 1d 	bne  4001eb98 <rtems_rfs_dir_del_entry+0x250>  <== NOT EXECUTED
4001eb28:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
4001eb2c:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001eb30:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001eb34:	7f ff f8 83 	call  4001cd40 <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001eb38:	94 07 bf a0 	add  %fp, -96, %o2                             <== NOT EXECUTED
      if (rc == ENXIO)                                                
4001eb3c:	80 a2 20 06 	cmp  %o0, 6                                    <== NOT EXECUTED
4001eb40:	02 80 00 85 	be  4001ed54 <rtems_rfs_dir_del_entry+0x40c>   <== NOT EXECUTED
4001eb44:	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)                                                     
4001eb48:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001eb4c:	02 bf ff b3 	be  4001ea18 <rtems_rfs_dir_del_entry+0xd0>    <== NOT EXECUTED
4001eb50:	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);                       
4001eb54:	10 80 00 11 	b  4001eb98 <rtems_rfs_dir_del_entry+0x250>    <== NOT EXECUTED
4001eb58:	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))          
4001eb5c:	7f ff d9 52 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001eb60:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    <== NOT EXECUTED
4001eb64:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001eb68:	22 80 00 0b 	be,a   4001eb94 <rtems_rfs_dir_del_entry+0x24c><== NOT EXECUTED
4001eb6c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
          printf ("rtems-rfs: dir-del-entry: "                        
4001eb70:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001eb74:	d8 07 bf a0 	ld  [ %fp + -96 ], %o4                         <== NOT EXECUTED
4001eb78:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001eb7c:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
4001eb80:	90 12 20 f0 	or  %o0, 0xf0, %o0                             <== NOT EXECUTED
4001eb84:	96 10 00 10 	mov  %l0, %o3                                  <== NOT EXECUTED
4001eb88:	40 00 19 7d 	call  4002517c <printf>                        <== NOT EXECUTED
4001eb8c:	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;                                                     
4001eb90:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4001eb94:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
4001eb98:	7f ff fa a8 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001eb9c:	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);                               
4001eba0:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001eba4:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001eba8:	c0 27 bf a8 	clr  [ %fp + -88 ]                             <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001ebac:	c0 27 bf ac 	clr  [ %fp + -84 ]                             <== NOT EXECUTED
4001ebb0:	7f ff f7 79 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001ebb4:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001ebb8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ebbc:	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);                
4001ebc0:	90 10 00 1b 	mov  %i3, %o0                                  
4001ebc4:	40 00 4b 04 	call  400317d4 <.urem>                         
4001ebc8:	92 10 00 15 	mov  %l5, %o1                                  
4001ebcc:	10 bf ff 9e 	b  4001ea44 <rtems_rfs_dir_del_entry+0xfc>     
4001ebd0:	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);
4001ebd4:	82 07 00 12 	add  %i4, %l2, %g1                             
        memmove (entry, entry + elength, remaining);                  
4001ebd8:	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);
4001ebdc:	aa 25 40 01 	sub  %l5, %g1, %l5                             
        memmove (entry, entry + elength, remaining);                  
4001ebe0:	90 10 00 1d 	mov  %i5, %o0                                  
4001ebe4:	40 00 18 96 	call  40024e3c <memmove>                       
4001ebe8:	94 10 00 15 	mov  %l5, %o2                                  
        memset (entry + remaining, 0xff, elength);                    
4001ebec:	92 10 20 ff 	mov  0xff, %o1                                 
4001ebf0:	94 10 00 1c 	mov  %i4, %o2                                  
4001ebf4:	40 00 18 e4 	call  40024f84 <memset>                        
4001ebf8:	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);                 
4001ebfc:	c2 0f 60 09 	ldub  [ %i5 + 9 ], %g1                         
4001ec00:	c4 0f 60 08 	ldub  [ %i5 + 8 ], %g2                         
                                                                      
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
4001ec04:	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);                 
4001ec08:	bb 28 a0 08 	sll  %g2, 8, %i5                               
                                                                      
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))          
4001ec0c:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    
4001ec10:	7f ff d9 25 	call  400150a4 <rtems_rfs_trace>               
4001ec14:	ba 17 40 01 	or  %i5, %g1, %i5                              
4001ec18:	80 8a 20 ff 	btst  0xff, %o0                                
4001ec1c:	02 80 00 17 	be  4001ec78 <rtems_rfs_dir_del_entry+0x330>   <== ALWAYS TAKEN
4001ec20:	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");    
4001ec24:	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: "                        
4001ec28:	d6 07 bf a0 	ld  [ %fp + -96 ], %o3                         <== NOT EXECUTED
4001ec2c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001ec30:	12 80 00 05 	bne  4001ec44 <rtems_rfs_dir_del_entry+0x2fc>  <== NOT EXECUTED
4001ec34:	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");    
4001ec38:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
4001ec3c:	02 80 00 3e 	be  4001ed34 <rtems_rfs_dir_del_entry+0x3ec>   <== NOT EXECUTED
4001ec40:	1b 10 00 db 	sethi  %hi(0x40036c00), %o5                    <== NOT EXECUTED
4001ec44:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
4001ec48:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
4001ec4c:	02 80 00 3a 	be  4001ed34 <rtems_rfs_dir_del_entry+0x3ec>   <== NOT EXECUTED
4001ec50:	1b 10 00 db 	sethi  %hi(0x40036c00), %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: "                        
4001ec54:	1b 10 00 d5 	sethi  %hi(0x40035400), %o5                    <== NOT EXECUTED
4001ec58:	9a 13 60 60 	or  %o5, 0x60, %o5	! 40035460 <Callbacks.6428+0x218><== NOT EXECUTED
4001ec5c:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001ec60:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001ec64:	90 12 21 40 	or  %o0, 0x140, %o0                            <== NOT EXECUTED
4001ec68:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001ec6c:	40 00 19 44 	call  4002517c <printf>                        <== NOT EXECUTED
4001ec70:	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) &&                 
4001ec74:	03 3f ff c0 	sethi  %hi(0xffff0000), %g1                    <== NOT EXECUTED
4001ec78:	ba 38 40 1d 	xnor  %g1, %i5, %i5                            
4001ec7c:	80 a7 60 00 	cmp  %i5, 0                                    
4001ec80:	12 80 00 1f 	bne  4001ecfc <rtems_rfs_dir_del_entry+0x3b4>  
4001ec84:	80 a4 a0 00 	cmp  %l2, 0                                    
4001ec88:	12 80 00 1d 	bne  4001ecfc <rtems_rfs_dir_del_entry+0x3b4>  <== ALWAYS TAKEN
4001ec8c:	c2 07 bf c0 	ld  [ %fp + -64 ], %g1                         
            (eoffset == 0) && rtems_rfs_block_map_last (&map))        
4001ec90:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001ec94:	12 80 00 2a 	bne  4001ed3c <rtems_rfs_dir_del_entry+0x3f4>  <== NOT EXECUTED
4001ec98:	c4 07 bf b8 	ld  [ %fp + -72 ], %g2                         <== NOT EXECUTED
4001ec9c:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
4001eca0:	12 80 00 28 	bne  4001ed40 <rtems_rfs_dir_del_entry+0x3f8>  <== NOT EXECUTED
4001eca4:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_block_map_shrink (fs, &map, 1);              
4001eca8:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001ecac:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001ecb0:	7f ff f9 27 	call  4001d14c <rtems_rfs_block_map_shrink>    <== NOT EXECUTED
4001ecb4:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
          if (rc > 0)                                                 
4001ecb8:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4001ecbc:	04 80 00 10 	ble  4001ecfc <rtems_rfs_dir_del_entry+0x3b4>  <== NOT EXECUTED
4001ecc0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
          {                                                           
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))      
4001ecc4:	7f ff d8 f8 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001ecc8:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    <== NOT EXECUTED
4001eccc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001ecd0:	02 80 00 0c 	be  4001ed00 <rtems_rfs_dir_del_entry+0x3b8>   <== NOT EXECUTED
4001ecd4:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
              printf ("rtems-rfs: dir-del-entry: "                    
4001ecd8:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001ecdc:	40 00 1d 72 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001ece0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001ece4:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001ece8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001ecec:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001ecf0:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001ecf4:	40 00 19 22 	call  4002517c <printf>                        <== NOT EXECUTED
4001ecf8:	90 12 21 a0 	or  %o0, 0x1a0, %o0	! 400389a0 <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);                        
4001ecfc:	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);                       
4001ed00:	92 07 bf a4 	add  %fp, -92, %o1                             
4001ed04:	90 10 00 11 	mov  %l1, %o0                                  
4001ed08:	7f ff fa 4c 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001ed0c:	c2 2f bf a4 	stb  %g1, [ %fp + -92 ]                        
        rtems_rfs_buffer_handle_close (fs, &buffer);                  
        rtems_rfs_block_map_close (fs, &map);                         
        return 0;                                                     
4001ed10:	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);                         
4001ed14:	90 10 00 11 	mov  %l1, %o0                                  
  handle->dirty = false;                                              
4001ed18:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001ed1c:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001ed20:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001ed24:	7f ff f7 1c 	call  4001c994 <rtems_rfs_block_map_close>     
4001ed28:	92 07 bf b0 	add  %fp, -80, %o1                             
4001ed2c:	81 c7 e0 08 	ret                                            
4001ed30:	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: "                        
4001ed34:	10 bf ff ca 	b  4001ec5c <rtems_rfs_dir_del_entry+0x314>    <== NOT EXECUTED
4001ed38:	9a 13 63 50 	or  %o5, 0x350, %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))        
4001ed3c:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
4001ed40:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
4001ed44:	12 bf ff ef 	bne  4001ed00 <rtems_rfs_dir_del_entry+0x3b8>  <== NOT EXECUTED
4001ed48:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
        {                                                             
          rc = rtems_rfs_block_map_shrink (fs, &map, 1);              
4001ed4c:	10 bf ff d8 	b  4001ecac <rtems_rfs_dir_del_entry+0x364>    <== NOT EXECUTED
4001ed50:	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;                                                  
4001ed54:	10 bf ff 90 	b  4001eb94 <rtems_rfs_dir_del_entry+0x24c>    <== NOT EXECUTED
4001ed58:	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))            
4001ed5c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001ed60:	7f ff d8 d1 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001ed64:	13 10 00 00 	sethi  %hi(0x40000000), %o1                    <== NOT EXECUTED
4001ed68:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001ed6c:	22 bf ff 8b 	be,a   4001eb98 <rtems_rfs_dir_del_entry+0x250><== NOT EXECUTED
4001ed70:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
        printf ("rtems-rfs: dir-del-entry: "                          
4001ed74:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           <== NOT EXECUTED
4001ed78:	40 00 1d 4b 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001ed7c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001ed80:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001ed84:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001ed88:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
4001ed8c:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001ed90:	40 00 18 fb 	call  4002517c <printf>                        <== NOT EXECUTED
4001ed94:	90 12 20 a8 	or  %o0, 0xa8, %o0	! 400388a8 <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);                       
4001ed98:	10 bf ff 80 	b  4001eb98 <rtems_rfs_dir_del_entry+0x250>    <== NOT EXECUTED
4001ed9c:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                                                                      

4001f154 <rtems_rfs_dir_empty>: } int rtems_rfs_dir_empty (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir) {
4001f154:	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))                     
4001f158:	90 10 20 00 	clr  %o0                                       
4001f15c:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
4001f160:	7f ff d7 d1 	call  400150a4 <rtems_rfs_trace>               
4001f164:	b4 10 00 18 	mov  %i0, %i2                                  
4001f168:	80 8a 20 ff 	btst  0xff, %o0                                
4001f16c:	12 80 00 0a 	bne  4001f194 <rtems_rfs_dir_empty+0x40>       <== NEVER TAKEN
4001f170:	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);                      
4001f174:	90 10 00 1a 	mov  %i2, %o0                                  
4001f178:	7f ff f5 a6 	call  4001c810 <rtems_rfs_block_map_open>      
4001f17c:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001f180:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001f184:	04 80 00 0f 	ble  4001f1c0 <rtems_rfs_dir_empty+0x6c>       <== ALWAYS TAKEN
4001f188:	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;                                                          
}                                                                     
4001f18c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001f190:	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));
4001f194:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001f198:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001f19c:	40 00 17 f8 	call  4002517c <printf>                        <== NOT EXECUTED
4001f1a0:	90 12 22 d0 	or  %o0, 0x2d0, %o0	! 40038ad0 <CSWTCH.2+0xce0><== NOT EXECUTED
                                                                      
  empty = true;                                                       
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
4001f1a4:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4001f1a8:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001f1ac:	7f ff f5 99 	call  4001c810 <rtems_rfs_block_map_open>      <== NOT EXECUTED
4001f1b0:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
  if (rc > 0)                                                         
4001f1b4:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001f1b8:	14 bf ff f5 	bg  4001f18c <rtems_rfs_dir_empty+0x38>        <== NOT EXECUTED
4001f1bc:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
    return rc;                                                        
                                                                      
  rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);                
4001f1c0:	92 07 bf b0 	add  %fp, -80, %o1                             
4001f1c4:	94 10 20 00 	clr  %o2                                       
4001f1c8:	96 10 20 00 	clr  %o3                                       
4001f1cc:	7f ff f6 c0 	call  4001cccc <rtems_rfs_block_map_seek>      
4001f1d0:	98 07 bf a0 	add  %fp, -96, %o4                             
  if (rc > 0)                                                         
4001f1d4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001f1d8:	14 80 00 7d 	bg  4001f3cc <rtems_rfs_dir_empty+0x278>       <== NEVER TAKEN
4001f1dc:	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: "                            
4001f1e0:	21 10 00 e2 	sethi  %hi(0x40038800), %l0                    
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001f1e4:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001f1e8:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001f1ec:	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)                       
4001f1f0:	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: "                            
4001f1f4:	a0 14 22 f0 	or  %l0, 0x2f0, %l0                            
  while (empty)                                                       
  {                                                                   
    uint8_t* entry;                                                   
    int      offset;                                                  
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
4001f1f8:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
4001f1fc:	90 10 00 1a 	mov  %i2, %o0                                  
4001f200:	92 07 bf a4 	add  %fp, -92, %o1                             
4001f204:	7f ff f9 87 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001f208:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
4001f20c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001f210:	14 80 00 4d 	bg  4001f344 <rtems_rfs_dir_empty+0x1f0>       <== NEVER TAKEN
4001f214:	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))
4001f218:	da 06 a0 08 	ld  [ %i2 + 8 ], %o5                           
4001f21c:	9a 83 7f f6 	addcc  %o5, -10, %o5                           
4001f220:	02 80 00 5f 	be  4001f39c <rtems_rfs_dir_empty+0x248>       <== NEVER TAKEN
4001f224:	c2 00 60 1c 	ld  [ %g1 + 0x1c ], %g1                        
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001f228:	fa 08 60 08 	ldub  [ %g1 + 8 ], %i5                         
4001f22c:	f6 08 60 09 	ldub  [ %g1 + 9 ], %i3                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001f230:	f8 08 40 00 	ldub  [ %g1 ], %i4                             
4001f234:	c8 08 60 02 	ldub  [ %g1 + 2 ], %g4                         
4001f238:	c6 08 60 03 	ldub  [ %g1 + 3 ], %g3                         
4001f23c:	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);                   
4001f240:	bb 2f 60 08 	sll  %i5, 8, %i5                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001f244:	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);                   
4001f248:	ba 17 40 1b 	or  %i5, %i3, %i5                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001f24c:	89 29 20 08 	sll  %g4, 8, %g4                               
4001f250:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
4001f254:	b8 17 00 04 	or  %i4, %g4, %i4                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001f258:	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);                      
4001f25c:	b8 17 00 03 	or  %i4, %g3, %i4                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001f260:	02 80 00 4f 	be  4001f39c <rtems_rfs_dir_empty+0x248>       <== NEVER TAKEN
4001f264:	b8 17 00 02 	or  %i4, %g2, %i4                              
4001f268:	10 80 00 20 	b  4001f2e8 <rtems_rfs_dir_empty+0x194>        
4001f26c:	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] != '.')) &&               
4001f270:	12 80 00 31 	bne  4001f334 <rtems_rfs_dir_empty+0x1e0>      
4001f274:	80 a0 00 18 	cmp  %g0, %i0                                  
          ((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||             
4001f278:	c4 08 60 0a 	ldub  [ %g1 + 0xa ], %g2                       
4001f27c:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001f280:	12 80 00 2d 	bne  4001f334 <rtems_rfs_dir_empty+0x1e0>      <== NEVER TAKEN
4001f284:	80 a0 00 18 	cmp  %g0, %i0                                  
           (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||                
4001f288:	c4 08 60 0b 	ldub  [ %g1 + 0xb ], %g2                       
4001f28c:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001f290:	12 80 00 29 	bne  4001f334 <rtems_rfs_dir_empty+0x1e0>      <== NEVER TAKEN
4001f294:	80 a0 00 18 	cmp  %g0, %i0                                  
        empty = false;                                                
        break;                                                        
      }                                                               
                                                                      
      entry  += elength;                                              
      offset += elength;                                              
4001f298:	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))
4001f29c:	80 a6 c0 0d 	cmp  %i3, %o5                                  
4001f2a0:	1a 80 00 3f 	bcc  4001f39c <rtems_rfs_dir_empty+0x248>      <== NEVER TAKEN
4001f2a4:	82 00 40 1d 	add  %g1, %i5, %g1                             
    {                                                                 
      rtems_rfs_ino eino;                                             
      int           elength;                                          
                                                                      
      elength = rtems_rfs_dir_entry_length (entry);                   
4001f2a8:	fa 08 60 08 	ldub  [ %g1 + 8 ], %i5                         
4001f2ac:	de 08 60 09 	ldub  [ %g1 + 9 ], %o7                         
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001f2b0:	f8 08 40 00 	ldub  [ %g1 ], %i4                             
4001f2b4:	c8 08 60 01 	ldub  [ %g1 + 1 ], %g4                         
4001f2b8:	c6 08 60 03 	ldub  [ %g1 + 3 ], %g3                         
4001f2bc:	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);                   
4001f2c0:	bb 2f 60 08 	sll  %i5, 8, %i5                               
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001f2c4:	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);                   
4001f2c8:	ba 17 40 0f 	or  %i5, %o7, %i5                              
      eino    = rtems_rfs_dir_entry_ino (entry);                      
4001f2cc:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001f2d0:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001f2d4:	b8 17 00 04 	or  %i4, %g4, %i4                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001f2d8:	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);                      
4001f2dc:	b8 17 00 03 	or  %i4, %g3, %i4                              
                                                                      
      if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                       
4001f2e0:	02 80 00 2f 	be  4001f39c <rtems_rfs_dir_empty+0x248>       
4001f2e4:	b8 17 00 02 	or  %i4, %g2, %i4                              
        break;                                                        
                                                                      
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
4001f2e8:	80 a7 60 0a 	cmp  %i5, 0xa                                  
4001f2ec:	04 80 00 21 	ble  4001f370 <rtems_rfs_dir_empty+0x21c>      <== NEVER TAKEN
4001f2f0:	90 10 20 01 	mov  1, %o0                                    
4001f2f4:	c4 06 a0 1c 	ld  [ %i2 + 0x1c ], %g2                        
4001f2f8:	80 a7 40 02 	cmp  %i5, %g2                                  
4001f2fc:	1a 80 00 1d 	bcc  4001f370 <rtems_rfs_dir_empty+0x21c>      <== NEVER TAKEN
4001f300:	80 a7 20 00 	cmp  %i4, 0                                    
4001f304:	02 80 00 1b 	be  4001f370 <rtems_rfs_dir_empty+0x21c>       <== NEVER TAKEN
4001f308:	01 00 00 00 	nop                                            
4001f30c:	c4 06 a0 14 	ld  [ %i2 + 0x14 ], %g2                        
4001f310:	80 a0 80 1c 	cmp  %g2, %i4                                  
4001f314:	0a 80 00 17 	bcs  4001f370 <rtems_rfs_dir_empty+0x21c>      <== NEVER TAKEN
4001f318:	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)) ||             
4001f31c:	12 bf ff d5 	bne  4001f270 <rtems_rfs_dir_empty+0x11c>      
4001f320:	80 a7 60 0c 	cmp  %i5, 0xc                                  
4001f324:	c4 08 60 0a 	ldub  [ %g1 + 0xa ], %g2                       
4001f328:	80 a0 a0 2e 	cmp  %g2, 0x2e                                 
4001f32c:	02 bf ff db 	be  4001f298 <rtems_rfs_dir_empty+0x144>       <== ALWAYS TAKEN
4001f330:	80 a0 00 18 	cmp  %g0, %i0                                  
4001f334:	82 60 3f ff 	subx  %g0, -1, %g1                             
        break;                                                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ((rc == 0) && !empty)                                            
4001f338:	80 88 60 ff 	btst  0xff, %g1                                
4001f33c:	32 80 00 02 	bne,a   4001f344 <rtems_rfs_dir_empty+0x1f0>   <== ALWAYS TAKEN
4001f340:	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);                       
4001f344:	92 07 bf a4 	add  %fp, -92, %o1                             
4001f348:	7f ff f8 bc 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001f34c:	90 10 00 1a 	mov  %i2, %o0                                  
    rc = ENOTEMPTY;                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
4001f350:	90 10 00 1a 	mov  %i2, %o0                                  
  handle->dirty = false;                                              
4001f354:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001f358:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001f35c:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001f360:	7f ff f5 8d 	call  4001c994 <rtems_rfs_block_map_close>     
4001f364:	92 07 bf b0 	add  %fp, -80, %o1                             
4001f368:	81 c7 e0 08 	ret                                            
4001f36c:	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))              
4001f370:	7f ff d7 4d 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f374:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001f378:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f37c:	02 80 00 09 	be  4001f3a0 <rtems_rfs_dir_empty+0x24c>       <== NOT EXECUTED
4001f380:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
          printf ("rtems-rfs: dir-empty: "                            
4001f384:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001f388:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001f38c:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001f390:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
4001f394:	40 00 17 7a 	call  4002517c <printf>                        <== NOT EXECUTED
4001f398:	98 10 00 1b 	mov  %i3, %o4                                  <== NOT EXECUTED
      offset += elength;                                              
    }                                                                 
                                                                      
    if (empty)                                                        
    {                                                                 
      rc = rtems_rfs_block_map_next_block (fs, &map, &block);         
4001f39c:	90 10 00 1a 	mov  %i2, %o0                                  
4001f3a0:	92 07 bf b0 	add  %fp, -80, %o1                             
4001f3a4:	7f ff f6 67 	call  4001cd40 <rtems_rfs_block_map_next_block>
4001f3a8:	94 07 bf a0 	add  %fp, -96, %o2                             
      if (rc > 0)                                                     
4001f3ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001f3b0:	04 bf ff 93 	ble  4001f1fc <rtems_rfs_dir_empty+0xa8>       <== NEVER TAKEN
4001f3b4:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
      {                                                               
        if (rc == ENXIO)                                              
          rc = 0;                                                     
4001f3b8:	82 1e 20 06 	xor  %i0, 6, %g1                               
4001f3bc:	80 a0 00 01 	cmp  %g0, %g1                                  
4001f3c0:	82 60 20 00 	subx  %g0, 0, %g1                              
4001f3c4:	10 bf ff e0 	b  4001f344 <rtems_rfs_dir_empty+0x1f0>        
4001f3c8:	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);                             
4001f3cc:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4001f3d0:	7f ff f5 71 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001f3d4:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001f3d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001f3dc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40023778 <rtems_rfs_dir_hash>: */ #define initval (20010928) uint32_t rtems_rfs_dir_hash (const void *key, size_t length) {
40023778:	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;              
4002377c:	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)                                               
40023780:	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;              
40023784:	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)                                               
40023788:	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;              
4002378c:	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)                                               
40023790:	84 10 00 04 	mov  %g4, %g2                                  
40023794:	08 80 00 4b 	bleu  400238c0 <rtems_rfs_dir_hash+0x148>      
40023798:	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;                                     
4002379c:	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;                                      
400237a0:	fa 08 60 03 	ldub  [ %g1 + 3 ], %i5                         
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
400237a4:	d8 08 60 05 	ldub  [ %g1 + 5 ], %o4                         
      b += ((uint32_t)k[6])<<16;                                      
400237a8:	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];                                                      
400237ac:	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;                                      
400237b0:	d4 08 60 07 	ldub  [ %g1 + 7 ], %o2                         
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
400237b4:	d6 08 60 09 	ldub  [ %g1 + 9 ], %o3                         
      c += ((uint32_t)k[10])<<16;                                     
400237b8:	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];                                                      
400237bc:	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;                                       
400237c0:	de 08 60 01 	ldub  [ %g1 + 1 ], %o7                         
      a += ((uint32_t)k[2])<<16;                                      
400237c4:	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];                                                      
400237c8:	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;                                     
400237cc:	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;                                      
400237d0:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
      b += k[4];                                                      
      b += ((uint32_t)k[5])<<8;                                       
400237d4:	99 2b 20 08 	sll  %o4, 8, %o4                               
      b += ((uint32_t)k[6])<<16;                                      
400237d8:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
      b += ((uint32_t)k[7])<<24;                                      
400237dc:	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];                                                      
400237e0:	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;                                       
400237e4:	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;                                       
400237e8:	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;                                     
400237ec:	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;                                      
400237f0:	98 03 00 0a 	add  %o4, %o2, %o4                             
      b += ((uint32_t)k[7])<<24;                                      
      c += k[8];                                                      
400237f4:	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;                                      
400237f8:	84 03 00 02 	add  %o4, %g2, %g2                             
      c += k[8];                                                      
      c += ((uint32_t)k[9])<<8;                                       
400237fc:	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;                                       
40023800:	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;                                     
40023804:	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;                                      
40023808:	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;                                     
4002380c:	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];                                                      
40023810:	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);                                                     
40023814:	88 06 00 02 	add  %i0, %g2, %g4                             
40023818:	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;                                       
4002381c:	b6 06 c0 1a 	add  %i3, %i2, %i3                             
      a += ((uint32_t)k[2])<<16;                                      
40023820:	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);                                                     
40023824:	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;                                      
40023828:	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);                                                     
4002382c:	ba 17 00 1d 	or  %i4, %i5, %i5                              
40023830:	86 06 00 03 	add  %i0, %g3, %g3                             
40023834:	b8 18 c0 1d 	xor  %g3, %i5, %i4                             
40023838:	86 07 00 04 	add  %i4, %g4, %g3                             
4002383c:	84 20 80 1c 	sub  %g2, %i4, %g2                             
40023840:	bb 2f 20 06 	sll  %i4, 6, %i5                               
40023844:	b9 37 20 1a 	srl  %i4, 0x1a, %i4                            
40023848:	ba 17 40 1c 	or  %i5, %i4, %i5                              
4002384c:	ba 1f 40 02 	xor  %i5, %g2, %i5                             
40023850:	84 07 40 03 	add  %i5, %g3, %g2                             
40023854:	88 21 00 1d 	sub  %g4, %i5, %g4                             
40023858:	b9 2f 60 08 	sll  %i5, 8, %i4                               
4002385c:	bb 37 60 18 	srl  %i5, 0x18, %i5                            
40023860:	ba 17 00 1d 	or  %i4, %i5, %i5                              
40023864:	88 1f 40 04 	xor  %i5, %g4, %g4                             
40023868:	b0 01 00 02 	add  %g4, %g2, %i0                             
4002386c:	bb 29 20 10 	sll  %g4, 0x10, %i5                            
40023870:	86 20 c0 04 	sub  %g3, %g4, %g3                             
40023874:	89 31 20 10 	srl  %g4, 0x10, %g4                            
40023878:	88 17 40 04 	or  %i5, %g4, %g4                              
4002387c:	86 19 00 03 	xor  %g4, %g3, %g3                             
40023880:	bb 28 e0 13 	sll  %g3, 0x13, %i5                            
40023884:	89 30 e0 0d 	srl  %g3, 0xd, %g4                             
40023888:	88 17 40 04 	or  %i5, %g4, %g4                              
4002388c:	84 20 80 03 	sub  %g2, %g3, %g2                             
      length -= 12;                                                   
40023890:	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);                                                     
40023894:	84 19 00 02 	xor  %g4, %g2, %g2                             
40023898:	86 00 c0 18 	add  %g3, %i0, %g3                             
4002389c:	bb 28 a0 04 	sll  %g2, 4, %i5                               
400238a0:	b0 26 00 02 	sub  %i0, %g2, %i0                             
400238a4:	89 30 a0 1c 	srl  %g2, 0x1c, %g4                            
      length -= 12;                                                   
      k += 12;                                                        
400238a8:	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);                                                     
400238ac:	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)                                               
400238b0:	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);                                                     
400238b4:	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)                                               
400238b8:	18 bf ff b9 	bgu  4002379c <rtems_rfs_dir_hash+0x24>        <== NEVER TAKEN
400238bc:	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 */
400238c0:	b3 2e 60 02 	sll  %i1, 2, %i1                               
400238c4:	3b 10 00 8d 	sethi  %hi(0x40023400), %i5                    
400238c8:	ba 17 63 44 	or  %i5, 0x344, %i5	! 40023744 <rtems_rfs_buffer_bdbuf_release+0x8c>
400238cc:	fa 07 40 19 	ld  [ %i5 + %i1 ], %i5                         
400238d0:	81 c7 40 00 	jmp  %i5                                       
400238d4:	01 00 00 00 	nop                                            
    {                                                                 
      case 12: c+=((uint32_t)k[11])<<24;                              
400238d8:	fa 08 60 0b 	ldub  [ %g1 + 0xb ], %i5                       
400238dc:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
400238e0:	88 01 00 1d 	add  %g4, %i5, %g4                             
      case 11: c+=((uint32_t)k[10])<<16;                              
400238e4:	fa 08 60 0a 	ldub  [ %g1 + 0xa ], %i5                       
400238e8:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
400238ec:	88 01 00 1d 	add  %g4, %i5, %g4                             
      case 10: c+=((uint32_t)k[9])<<8;                                
400238f0:	fa 08 60 09 	ldub  [ %g1 + 9 ], %i5                         
400238f4:	bb 2f 60 08 	sll  %i5, 8, %i5                               
400238f8:	88 01 00 1d 	add  %g4, %i5, %g4                             
      case 9 : c+=k[8];                                               
400238fc:	fa 08 60 08 	ldub  [ %g1 + 8 ], %i5                         
40023900:	88 01 00 1d 	add  %g4, %i5, %g4                             
      case 8 : b+=((uint32_t)k[7])<<24;                               
40023904:	fa 08 60 07 	ldub  [ %g1 + 7 ], %i5                         
40023908:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
4002390c:	84 00 80 1d 	add  %g2, %i5, %g2                             
      case 7 : b+=((uint32_t)k[6])<<16;                               
40023910:	fa 08 60 06 	ldub  [ %g1 + 6 ], %i5                         
40023914:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
40023918:	84 00 80 1d 	add  %g2, %i5, %g2                             
      case 6 : b+=((uint32_t)k[5])<<8;                                
4002391c:	fa 08 60 05 	ldub  [ %g1 + 5 ], %i5                         
40023920:	bb 2f 60 08 	sll  %i5, 8, %i5                               
40023924:	84 00 80 1d 	add  %g2, %i5, %g2                             
      case 5 : b+=k[4];                                               
40023928:	fa 08 60 04 	ldub  [ %g1 + 4 ], %i5                         
4002392c:	84 00 80 1d 	add  %g2, %i5, %g2                             
      case 4 : a+=((uint32_t)k[3])<<24;                               
40023930:	fa 08 60 03 	ldub  [ %g1 + 3 ], %i5                         
40023934:	bb 2f 60 18 	sll  %i5, 0x18, %i5                            
40023938:	86 00 c0 1d 	add  %g3, %i5, %g3                             
      case 3 : a+=((uint32_t)k[2])<<16;                               
4002393c:	fa 08 60 02 	ldub  [ %g1 + 2 ], %i5                         
40023940:	bb 2f 60 10 	sll  %i5, 0x10, %i5                            
40023944:	86 00 c0 1d 	add  %g3, %i5, %g3                             
      case 2 : a+=((uint32_t)k[1])<<8;                                
40023948:	fa 08 60 01 	ldub  [ %g1 + 1 ], %i5                         
4002394c:	bb 2f 60 08 	sll  %i5, 8, %i5                               
40023950:	86 00 c0 1d 	add  %g3, %i5, %g3                             
      case 1 : a+=k[0];                                               
40023954:	c2 08 40 00 	ldub  [ %g1 ], %g1                             
        break;                                                        
      case 0 : return c;                                              
    }                                                                 
  }                                                                   
                                                                      
  final(a,b,c);                                                       
40023958:	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];                                               
4002395c:	86 00 c0 01 	add  %g3, %g1, %g3                             
        break;                                                        
      case 0 : return c;                                              
    }                                                                 
  }                                                                   
                                                                      
  final(a,b,c);                                                       
40023960:	83 28 a0 0e 	sll  %g2, 0xe, %g1                             
40023964:	82 17 40 01 	or  %i5, %g1, %g1                              
40023968:	88 19 00 02 	xor  %g4, %g2, %g4                             
4002396c:	88 21 00 01 	sub  %g4, %g1, %g4                             
40023970:	bb 29 20 0b 	sll  %g4, 0xb, %i5                             
40023974:	83 31 20 15 	srl  %g4, 0x15, %g1                            
40023978:	82 17 40 01 	or  %i5, %g1, %g1                              
4002397c:	86 19 00 03 	xor  %g4, %g3, %g3                             
40023980:	86 20 c0 01 	sub  %g3, %g1, %g3                             
40023984:	bb 28 e0 19 	sll  %g3, 0x19, %i5                            
40023988:	83 30 e0 07 	srl  %g3, 7, %g1                               
4002398c:	82 17 40 01 	or  %i5, %g1, %g1                              
40023990:	84 18 c0 02 	xor  %g3, %g2, %g2                             
40023994:	84 20 80 01 	sub  %g2, %g1, %g2                             
40023998:	bb 28 a0 10 	sll  %g2, 0x10, %i5                            
4002399c:	83 30 a0 10 	srl  %g2, 0x10, %g1                            
400239a0:	82 17 40 01 	or  %i5, %g1, %g1                              
400239a4:	88 18 80 04 	xor  %g2, %g4, %g4                             
400239a8:	88 21 00 01 	sub  %g4, %g1, %g4                             
400239ac:	bb 29 20 04 	sll  %g4, 4, %i5                               
400239b0:	83 31 20 1c 	srl  %g4, 0x1c, %g1                            
400239b4:	82 17 40 01 	or  %i5, %g1, %g1                              
400239b8:	86 19 00 03 	xor  %g4, %g3, %g3                             
400239bc:	86 20 c0 01 	sub  %g3, %g1, %g3                             
400239c0:	84 18 c0 02 	xor  %g3, %g2, %g2                             
400239c4:	83 28 e0 0e 	sll  %g3, 0xe, %g1                             
400239c8:	87 30 e0 12 	srl  %g3, 0x12, %g3                            
400239cc:	86 10 40 03 	or  %g1, %g3, %g3                              
400239d0:	84 20 80 03 	sub  %g2, %g3, %g2                             
400239d4:	88 18 80 04 	xor  %g2, %g4, %g4                             
400239d8:	b1 28 a0 18 	sll  %g2, 0x18, %i0                            
400239dc:	85 30 a0 08 	srl  %g2, 8, %g2                               
400239e0:	84 16 00 02 	or  %i0, %g2, %g2                              
400239e4:	88 21 00 02 	sub  %g4, %g2, %g4                             
  return c;                                                           
}                                                                     
400239e8:	81 c7 e0 08 	ret                                            
400239ec:	91 e8 00 04 	restore  %g0, %g4, %o0                         
                                                                      

4001dfe8 <rtems_rfs_dir_lookup_ino>: rtems_rfs_inode_handle* inode, const char* name, int length, rtems_rfs_ino* ino, uint32_t* offset) {
4001dfe8:	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))               
4001dfec:	90 10 20 00 	clr  %o0                                       
4001dff0:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     
4001dff4:	7f ff dc 2c 	call  400150a4 <rtems_rfs_trace>               
4001dff8:	a2 10 00 18 	mov  %i0, %l1                                  
4001dffc:	80 8a 20 ff 	btst  0xff, %o0                                
4001e000:	12 80 00 1c 	bne  4001e070 <rtems_rfs_dir_lookup_ino+0x88>  <== NEVER TAKEN
4001e004:	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;                                         
4001e008:	c0 27 00 00 	clr  [ %i4 ]                                   
  *offset = 0;                                                        
4001e00c:	c0 27 40 00 	clr  [ %i5 ]                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, inode, &map);                    
4001e010:	90 10 00 11 	mov  %l1, %o0                                  
4001e014:	7f ff f9 ff 	call  4001c810 <rtems_rfs_block_map_open>      
4001e018:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001e01c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e020:	24 80 00 30 	ble,a   4001e0e0 <rtems_rfs_dir_lookup_ino+0xf8><== ALWAYS TAKEN
4001e024:	92 10 00 1b 	mov  %i3, %o1                                  
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))             
4001e028:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e02c:	7f ff dc 1e 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e030:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001e034:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e038:	32 80 00 04 	bne,a   4001e048 <rtems_rfs_dir_lookup_ino+0x60><== NOT EXECUTED
4001e03c:	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;                                                          
}                                                                     
4001e040:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e044:	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",
4001e048:	40 00 20 97 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001e04c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001e050:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001e054:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001e058:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
4001e05c:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e060:	40 00 1c 47 	call  4002517c <printf>                        <== NOT EXECUTED
4001e064:	90 12 20 80 	or  %o0, 0x80, %o0	! 40038480 <CSWTCH.2+0x690> <== NOT EXECUTED
4001e068:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001e06c:	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=",
4001e070:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001e074:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e078:	40 00 1c 41 	call  4002517c <printf>                        <== NOT EXECUTED
4001e07c:	90 12 20 38 	or  %o0, 0x38, %o0	! 40038438 <CSWTCH.2+0x648> <== NOT EXECUTED
4001e080:	b0 10 00 1a 	mov  %i2, %i0                                  <== NOT EXECUTED
            inode->ino);                                              
    for (c = 0; c < length; c++)                                      
4001e084:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
4001e088:	04 80 00 08 	ble  4001e0a8 <rtems_rfs_dir_lookup_ino+0xc0>  <== NOT EXECUTED
4001e08c:	a0 06 80 1b 	add  %i2, %i3, %l0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
4001e090:	d0 4e 00 00 	ldsb  [ %i0 ], %o0                             <== NOT EXECUTED
4001e094:	40 00 1c a4 	call  40025324 <putchar>                       <== NOT EXECUTED
4001e098:	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++)                                      
4001e09c:	80 a6 00 10 	cmp  %i0, %l0                                  <== NOT EXECUTED
4001e0a0:	32 bf ff fd 	bne,a   4001e094 <rtems_rfs_dir_lookup_ino+0xac><== NOT EXECUTED
4001e0a4:	d0 4e 00 00 	ldsb  [ %i0 ], %o0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (", len=%d\n", length);                                    
4001e0a8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001e0ac:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e0b0:	40 00 1c 33 	call  4002517c <printf>                        <== NOT EXECUTED
4001e0b4:	90 12 20 70 	or  %o0, 0x70, %o0	! 40038470 <CSWTCH.2+0x680> <== NOT EXECUTED
  }                                                                   
                                                                      
  *ino = RTEMS_RFS_EMPTY_INO;                                         
4001e0b8:	c0 27 00 00 	clr  [ %i4 ]                                   <== NOT EXECUTED
  *offset = 0;                                                        
4001e0bc:	c0 27 40 00 	clr  [ %i5 ]                                   <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_block_map_open (fs, inode, &map);                    
4001e0c0:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
4001e0c4:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001e0c8:	7f ff f9 d2 	call  4001c810 <rtems_rfs_block_map_open>      <== NOT EXECUTED
4001e0cc:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
  if (rc > 0)                                                         
4001e0d0:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
4001e0d4:	14 bf ff d6 	bg  4001e02c <rtems_rfs_dir_lookup_ino+0x44>   <== NOT EXECUTED
4001e0d8:	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);                         
4001e0dc:	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;                                              
4001e0e0:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001e0e4:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001e0e8:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001e0ec:	40 00 15 a3 	call  40023778 <rtems_rfs_dir_hash>            
4001e0f0:	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);              
4001e0f4:	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);                         
4001e0f8:	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);              
4001e0fc:	94 10 20 00 	clr  %o2                                       
4001e100:	90 10 00 11 	mov  %l1, %o0                                  
4001e104:	96 10 20 00 	clr  %o3                                       
4001e108:	7f ff fa f1 	call  4001cccc <rtems_rfs_block_map_seek>      
4001e10c:	98 07 bf a0 	add  %fp, -96, %o4                             
    if (rc > 0)                                                       
4001e110:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001e114:	04 80 00 15 	ble  4001e168 <rtems_rfs_dir_lookup_ino+0x180> <== ALWAYS TAKEN
4001e118:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
4001e11c:	7f ff db e2 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e120:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001e124:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e128:	12 80 00 bf 	bne  4001e424 <rtems_rfs_dir_lookup_ino+0x43c> <== NOT EXECUTED
4001e12c:	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)                                                
4001e130:	80 a6 20 06 	cmp  %i0, 6                                    <== NOT EXECUTED
4001e134:	22 80 00 02 	be,a   4001e13c <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
4001e138:	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);                       
4001e13c:	92 07 bf a4 	add  %fp, -92, %o1                             
4001e140:	7f ff fd 3e 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001e144:	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);                               
4001e148:	90 10 00 11 	mov  %l1, %o0                                  
  handle->dirty = false;                                              
4001e14c:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001e150:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001e154:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001e158:	7f ff fa 0f 	call  4001c994 <rtems_rfs_block_map_close>     
4001e15c:	92 07 bf b0 	add  %fp, -80, %o1                             
4001e160:	81 c7 e0 08 	ret                                            
4001e164:	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",
4001e168:	2d 10 00 e1 	sethi  %hi(0x40038400), %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)                     
4001e16c:	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: "                     
4001e170:	2b 10 00 e1 	sethi  %hi(0x40038400), %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",
4001e174:	ac 15 a1 00 	or  %l6, 0x100, %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)                     
4001e178:	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: "                     
4001e17c:	aa 15 61 d0 	or  %l5, 0x1d0, %l5                            
      rtems_rfs_buffer_handle_close (fs, &entries);                   
      rtems_rfs_block_map_close (fs, &map);                           
      return rc;                                                      
    }                                                                 
                                                                      
    while ((rc == 0) && block)                                        
4001e180:	80 a6 20 00 	cmp  %i0, 0                                    
4001e184:	12 80 00 6b 	bne  4001e330 <rtems_rfs_dir_lookup_ino+0x348> <== NEVER TAKEN
4001e188:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
4001e18c:	80 a0 60 00 	cmp  %g1, 0                                    
4001e190:	02 80 00 d3 	be  4001e4dc <rtems_rfs_dir_lookup_ino+0x4f4>  <== NEVER TAKEN
4001e194:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      uint8_t* entry;                                                 
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))           
4001e198:	7f ff db c3 	call  400150a4 <rtems_rfs_trace>               
4001e19c:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     
4001e1a0:	80 8a 20 ff 	btst  0xff, %o0                                
4001e1a4:	32 80 00 87 	bne,a   4001e3c0 <rtems_rfs_dir_lookup_ino+0x3d8><== NEVER TAKEN
4001e1a8:	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);
4001e1ac:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
4001e1b0:	90 10 00 11 	mov  %l1, %o0                                  
4001e1b4:	92 07 bf a4 	add  %fp, -92, %o1                             
4001e1b8:	7f ff fd 9a 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001e1bc:	96 10 20 01 	mov  1, %o3                                    
      if (rc > 0)                                                     
4001e1c0:	a8 92 20 00 	orcc  %o0, 0, %l4                              
4001e1c4:	14 80 00 b3 	bg  4001e490 <rtems_rfs_dir_lookup_ino+0x4a8>  <== NEVER TAKEN
4001e1c8:	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))
4001e1cc:	d8 04 60 08 	ld  [ %l1 + 8 ], %o4                           
       * means the entry is empty.                                    
       */                                                             
                                                                      
      entry = rtems_rfs_buffer_data (&entries);                       
                                                                      
      map.bpos.boff = 0;                                              
4001e1d0:	c0 27 bf c4 	clr  [ %fp + -60 ]                             
                                                                      
      while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
4001e1d4:	80 a3 20 0a 	cmp  %o4, 0xa                                  
4001e1d8:	12 80 00 0a 	bne  4001e200 <rtems_rfs_dir_lookup_ino+0x218> <== ALWAYS TAKEN
4001e1dc:	e0 00 60 1c 	ld  [ %g1 + 0x1c ], %l0                        
                                                                      
        map.bpos.boff += elength;                                     
        entry += elength;                                             
      }                                                               
                                                                      
      if (rc == 0)                                                    
4001e1e0:	10 80 00 47 	b  4001e2fc <rtems_rfs_dir_lookup_ino+0x314>   <== NOT EXECUTED
4001e1e4:	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))
4001e1e8:	86 03 3f f6 	add  %o4, -10, %g3                             
            rtems_rfs_block_map_close (fs, &map);                     
            return 0;                                                 
          }                                                           
        }                                                             
                                                                      
        map.bpos.boff += elength;                                     
4001e1ec:	84 05 c0 02 	add  %l7, %g2, %g2                             
4001e1f0:	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))
4001e1f4:	80 a0 c0 02 	cmp  %g3, %g2                                  
4001e1f8:	08 80 00 40 	bleu  4001e2f8 <rtems_rfs_dir_lookup_ino+0x310><== NEVER TAKEN
4001e1fc:	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);                       
4001e200:	c4 0c 00 00 	ldub  [ %l0 ], %g2                             
4001e204:	d0 0c 20 01 	ldub  [ %l0 + 1 ], %o0                         
4001e208:	d2 0c 20 03 	ldub  [ %l0 + 3 ], %o1                         
4001e20c:	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);                    
4001e210:	d6 0c 20 04 	ldub  [ %l0 + 4 ], %o3                         
4001e214:	c8 0c 20 05 	ldub  [ %l0 + 5 ], %g4                         
4001e218:	da 0c 20 07 	ldub  [ %l0 + 7 ], %o5                         
4001e21c:	c6 0c 20 06 	ldub  [ %l0 + 6 ], %g3                         
        elength = rtems_rfs_dir_entry_length (entry);                 
4001e220:	c2 0c 20 08 	ldub  [ %l0 + 8 ], %g1                         
4001e224:	de 0c 20 09 	ldub  [ %l0 + 9 ], %o7                         
        *ino = rtems_rfs_dir_entry_ino (entry);                       
4001e228:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
4001e22c:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
4001e230:	95 2a a0 08 	sll  %o2, 8, %o2                               
4001e234:	84 10 80 08 	or  %g2, %o0, %g2                              
4001e238:	84 10 80 09 	or  %g2, %o1, %g2                              
4001e23c:	84 10 80 0a 	or  %g2, %o2, %g2                              
4001e240:	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);                    
4001e244:	97 2a e0 18 	sll  %o3, 0x18, %o3                            
4001e248:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001e24c:	87 28 e0 08 	sll  %g3, 8, %g3                               
4001e250:	88 12 c0 04 	or  %o3, %g4, %g4                              
        elength = rtems_rfs_dir_entry_length (entry);                 
4001e254:	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);                    
4001e258:	88 11 00 0d 	or  %g4, %o5, %g4                              
        elength = rtems_rfs_dir_entry_length (entry);                 
4001e25c:	ae 10 40 0f 	or  %g1, %o7, %l7                              
        *ino = rtems_rfs_dir_entry_ino (entry);                       
                                                                      
        if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)                     
4001e260:	80 a5 c0 12 	cmp  %l7, %l2                                  
4001e264:	02 80 00 25 	be  4001e2f8 <rtems_rfs_dir_lookup_ino+0x310>  
4001e268:	86 11 00 03 	or  %g4, %g3, %g3                              
          break;                                                      
                                                                      
        if (rtems_rfs_dir_entry_valid (fs, elength, *ino))            
4001e26c:	80 a5 e0 0a 	cmp  %l7, 0xa                                  
4001e270:	24 80 00 34 	ble,a   4001e340 <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
4001e274:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e278:	de 04 60 1c 	ld  [ %l1 + 0x1c ], %o7                        
4001e27c:	80 a5 c0 0f 	cmp  %l7, %o7                                  
4001e280:	1a 80 00 2f 	bcc  4001e33c <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
4001e284:	80 a0 a0 00 	cmp  %g2, 0                                    
4001e288:	22 80 00 2e 	be,a   4001e340 <rtems_rfs_dir_lookup_ino+0x358><== NEVER TAKEN
4001e28c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e290:	c8 04 60 14 	ld  [ %l1 + 0x14 ], %g4                        
4001e294:	80 a0 80 04 	cmp  %g2, %g4                                  
4001e298:	18 80 00 29 	bgu  4001e33c <rtems_rfs_dir_lookup_ino+0x354> <== NEVER TAKEN
4001e29c:	80 a0 c0 13 	cmp  %g3, %l3                                  
                    rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
          rc = EIO;                                                   
          break;                                                      
        }                                                             
                                                                      
        if (ehash == hash)                                            
4001e2a0:	12 bf ff d2 	bne  4001e1e8 <rtems_rfs_dir_lookup_ino+0x200> 
4001e2a4:	c4 07 bf c4 	ld  [ %fp + -60 ], %g2                         
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 
4001e2a8:	90 10 20 00 	clr  %o0                                       
4001e2ac:	7f ff db 7e 	call  400150a4 <rtems_rfs_trace>               
4001e2b0:	13 02 00 00 	sethi  %hi(0x8000000), %o1                     
4001e2b4:	80 8a 20 ff 	btst  0xff, %o0                                
4001e2b8:	32 80 00 32 	bne,a   4001e380 <rtems_rfs_dir_lookup_ino+0x398><== NEVER TAKEN
4001e2bc:	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)
4001e2c0:	90 04 20 0a 	add  %l0, 0xa, %o0                             
4001e2c4:	92 10 00 1a 	mov  %i2, %o1                                  
4001e2c8:	40 00 1a 76 	call  40024ca0 <memcmp>                        
4001e2cc:	94 10 00 1b 	mov  %i3, %o2                                  
4001e2d0:	80 a2 20 00 	cmp  %o0, 0                                    
4001e2d4:	02 80 00 5d 	be  4001e448 <rtems_rfs_dir_lookup_ino+0x460>  <== ALWAYS TAKEN
4001e2d8:	c4 07 bf c4 	ld  [ %fp + -60 ], %g2                         
4001e2dc:	d8 04 60 08 	ld  [ %l1 + 8 ], %o4                           <== NOT EXECUTED
            rtems_rfs_block_map_close (fs, &map);                     
            return 0;                                                 
          }                                                           
        }                                                             
                                                                      
        map.bpos.boff += elength;                                     
4001e2e0:	84 05 c0 02 	add  %l7, %g2, %g2                             <== NOT EXECUTED
4001e2e4:	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))
4001e2e8:	86 03 3f f6 	add  %o4, -10, %g3                             <== NOT EXECUTED
4001e2ec:	80 a0 c0 02 	cmp  %g3, %g2                                  <== NOT EXECUTED
4001e2f0:	18 bf ff c4 	bgu  4001e200 <rtems_rfs_dir_lookup_ino+0x218> <== NOT EXECUTED
4001e2f4:	a0 04 00 17 	add  %l0, %l7, %l0                             <== NOT EXECUTED
                                                                      
        map.bpos.boff += elength;                                     
        entry += elength;                                             
      }                                                               
                                                                      
      if (rc == 0)                                                    
4001e2f8:	80 a5 20 00 	cmp  %l4, 0                                    
4001e2fc:	32 bf ff 90 	bne,a   4001e13c <rtems_rfs_dir_lookup_ino+0x154><== NEVER TAKEN
4001e300:	b0 10 00 14 	mov  %l4, %i0                                  <== NOT EXECUTED
      {                                                               
        rc = rtems_rfs_block_map_next_block (fs, &map, &block);       
4001e304:	90 10 00 11 	mov  %l1, %o0                                  
4001e308:	92 07 bf b0 	add  %fp, -80, %o1                             
4001e30c:	7f ff fa 8d 	call  4001cd40 <rtems_rfs_block_map_next_block>
4001e310:	94 07 bf a0 	add  %fp, -96, %o2                             
        if ((rc > 0) && (rc != ENXIO))                                
4001e314:	80 a2 20 06 	cmp  %o0, 6                                    
4001e318:	12 80 00 2f 	bne  4001e3d4 <rtems_rfs_dir_lookup_ino+0x3ec> <== NEVER TAKEN
4001e31c:	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)                                              
4001e320:	80 a6 20 06 	cmp  %i0, 6                                    
4001e324:	12 bf ff 98 	bne  4001e184 <rtems_rfs_dir_lookup_ino+0x19c> <== NEVER TAKEN
4001e328:	80 a6 20 00 	cmp  %i0, 0                                    
          rc = ENOENT;                                                
4001e32c:	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)                                        
4001e330:	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;                                                
4001e334:	10 bf ff 82 	b  4001e13c <rtems_rfs_dir_lookup_ino+0x154>   
4001e338:	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))       
4001e33c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e340:	7f ff db 59 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e344:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001e348:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e34c:	12 80 00 04 	bne  4001e35c <rtems_rfs_dir_lookup_ino+0x374> <== NOT EXECUTED
4001e350:	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;                                                
4001e354:	10 bf ff 7a 	b  4001e13c <rtems_rfs_dir_lookup_ino+0x154>   <== NOT EXECUTED
4001e358:	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: "                     
4001e35c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001e360:	d6 07 00 00 	ld  [ %i4 ], %o3                               <== NOT EXECUTED
4001e364:	d8 07 bf c4 	ld  [ %fp + -60 ], %o4                         <== NOT EXECUTED
4001e368:	94 10 00 17 	mov  %l7, %o2                                  <== NOT EXECUTED
4001e36c:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e370:	40 00 1b 83 	call  4002517c <printf>                        <== NOT EXECUTED
4001e374:	90 12 21 80 	or  %o0, 0x180, %o0	! 40038580 <CSWTCH.2+0x790><== NOT EXECUTED
4001e378:	10 bf ff 71 	b  4001e13c <rtems_rfs_dir_lookup_ino+0x154>   <== NOT EXECUTED
4001e37c:	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));        
4001e380:	c4 0c 20 02 	ldub  [ %l0 + 2 ], %g2                         <== NOT EXECUTED
4001e384:	da 0c 00 00 	ldub  [ %l0 ], %o5                             <== NOT EXECUTED
4001e388:	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: "                     
4001e38c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001e390:	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));        
4001e394:	89 29 20 10 	sll  %g4, 0x10, %g4                            <== NOT EXECUTED
4001e398:	85 28 a0 08 	sll  %g2, 8, %g2                               <== NOT EXECUTED
4001e39c:	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: "                     
4001e3a0:	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));        
4001e3a4:	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: "                     
4001e3a8:	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));        
4001e3ac:	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: "                     
4001e3b0:	40 00 1b 73 	call  4002517c <printf>                        <== NOT EXECUTED
4001e3b4:	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)
4001e3b8:	10 bf ff c3 	b  4001e2c4 <rtems_rfs_dir_lookup_ino+0x2dc>   <== NOT EXECUTED
4001e3bc:	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",
4001e3c0:	d4 07 bf c0 	ld  [ %fp + -64 ], %o2                         <== NOT EXECUTED
4001e3c4:	40 00 1b 6e 	call  4002517c <printf>                        <== NOT EXECUTED
4001e3c8:	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);
4001e3cc:	10 bf ff 79 	b  4001e1b0 <rtems_rfs_dir_lookup_ino+0x1c8>   <== NOT EXECUTED
4001e3d0:	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))                                
4001e3d4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001e3d8:	04 bf ff d3 	ble  4001e324 <rtems_rfs_dir_lookup_ino+0x33c> <== NOT EXECUTED
4001e3dc:	80 a6 20 06 	cmp  %i0, 6                                    <== NOT EXECUTED
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))       
4001e3e0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e3e4:	7f ff db 30 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e3e8:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001e3ec:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e3f0:	22 bf ff cd 	be,a   4001e324 <rtems_rfs_dir_lookup_ino+0x33c><== NOT EXECUTED
4001e3f4:	80 a6 20 06 	cmp  %i0, 6                                    <== NOT EXECUTED
            printf ("rtems-rfs: dir-lookup-ino: "                     
4001e3f8:	e0 06 60 08 	ld  [ %i1 + 8 ], %l0                           <== NOT EXECUTED
4001e3fc:	40 00 1f aa 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001e400:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001e404:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
4001e408:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001e40c:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
4001e410:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e414:	40 00 1b 5a 	call  4002517c <printf>                        <== NOT EXECUTED
4001e418:	90 12 22 78 	or  %o0, 0x278, %o0	! 40038678 <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)                                        
4001e41c:	10 bf ff 5a 	b  4001e184 <rtems_rfs_dir_lookup_ino+0x19c>   <== NOT EXECUTED
4001e420:	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",
4001e424:	40 00 1f a0 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001e428:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001e42c:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001e430:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001e434:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e438:	40 00 1b 51 	call  4002517c <printf>                        <== NOT EXECUTED
4001e43c:	90 12 20 c0 	or  %o0, 0xc0, %o0	! 400384c0 <CSWTCH.2+0x6d0> <== NOT EXECUTED
                rc, strerror (rc));                                   
      if (rc == ENXIO)                                                
4001e440:	10 bf ff 3d 	b  4001e134 <rtems_rfs_dir_lookup_ino+0x14c>   <== NOT EXECUTED
4001e444:	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);             
4001e448:	90 10 00 11 	mov  %l1, %o0                                  
4001e44c:	7f ff f8 bc 	call  4001c73c <rtems_rfs_block_get_pos>       
4001e450:	92 07 bf c0 	add  %fp, -64, %o1                             
                                                                      
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001e454:	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);             
4001e458:	d2 27 40 00 	st  %o1, [ %i5 ]                               
                                                                      
            if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
4001e45c:	7f ff db 12 	call  400150a4 <rtems_rfs_trace>               
4001e460:	13 04 00 00 	sethi  %hi(0x10000000), %o1                    
4001e464:	80 8a 20 ff 	btst  0xff, %o0                                
4001e468:	22 bf ff 36 	be,a   4001e140 <rtems_rfs_dir_lookup_ino+0x158><== ALWAYS TAKEN
4001e46c:	92 07 bf a4 	add  %fp, -92, %o1                             
              printf ("rtems-rfs: dir-lookup-ino: "                   
4001e470:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001e474:	d4 07 00 00 	ld  [ %i4 ], %o2                               <== NOT EXECUTED
4001e478:	d6 07 40 00 	ld  [ %i5 ], %o3                               <== NOT EXECUTED
4001e47c:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e480:	40 00 1b 3f 	call  4002517c <printf>                        <== NOT EXECUTED
4001e484:	90 12 22 30 	or  %o0, 0x230, %o0	! 40038630 <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);                       
4001e488:	10 bf ff 2e 	b  4001e140 <rtems_rfs_dir_lookup_ino+0x158>   <== NOT EXECUTED
4001e48c:	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))         
4001e490:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001e494:	7f ff db 04 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e498:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001e49c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e4a0:	22 bf ff 27 	be,a   4001e13c <rtems_rfs_dir_lookup_ino+0x154><== NOT EXECUTED
4001e4a4:	b0 10 00 14 	mov  %l4, %i0                                  <== NOT EXECUTED
          printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
4001e4a8:	f8 06 60 08 	ld  [ %i1 + 8 ], %i4                           <== NOT EXECUTED
4001e4ac:	fa 07 bf a0 	ld  [ %fp + -96 ], %i5                         <== NOT EXECUTED
4001e4b0:	40 00 1f 7d 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001e4b4:	90 10 00 14 	mov  %l4, %o0                                  <== NOT EXECUTED
4001e4b8:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001e4bc:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
4001e4c0:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001e4c4:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
4001e4c8:	96 10 00 14 	mov  %l4, %o3                                  <== NOT EXECUTED
4001e4cc:	40 00 1b 2c 	call  4002517c <printf>                        <== NOT EXECUTED
4001e4d0:	90 12 21 38 	or  %o0, 0x138, %o0                            <== NOT EXECUTED
4001e4d4:	10 bf ff 1a 	b  4001e13c <rtems_rfs_dir_lookup_ino+0x154>   <== NOT EXECUTED
4001e4d8:	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))           
4001e4dc:	13 01 00 00 	sethi  %hi(0x4000000), %o1                     <== NOT EXECUTED
4001e4e0:	7f ff da f1 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001e4e4:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4001e4e8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001e4ec:	22 bf ff 15 	be,a   4001e140 <rtems_rfs_dir_lookup_ino+0x158><== NOT EXECUTED
4001e4f0:	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",
4001e4f4:	fa 06 60 08 	ld  [ %i1 + 8 ], %i5                           <== NOT EXECUTED
4001e4f8:	40 00 1f 6b 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001e4fc:	90 10 20 05 	mov  5, %o0                                    <== NOT EXECUTED
4001e500:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4001e504:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001e508:	94 10 20 05 	mov  5, %o2                                    <== NOT EXECUTED
4001e50c:	11 10 00 e1 	sethi  %hi(0x40038400), %o0                    <== NOT EXECUTED
      }                                                               
    }                                                                 
                                                                      
    if ((rc == 0) && (block == 0))                                    
    {                                                                 
      rc = EIO;                                                       
4001e510:	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",
4001e514:	40 00 1b 1a 	call  4002517c <printf>                        <== NOT EXECUTED
4001e518:	90 12 22 c8 	or  %o0, 0x2c8, %o0                            <== NOT EXECUTED
4001e51c:	10 bf ff 09 	b  4001e140 <rtems_rfs_dir_lookup_ino+0x158>   <== NOT EXECUTED
4001e520:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                                                                      

4001eda0 <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) {
4001eda0:	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))                     
4001eda4:	90 10 20 00 	clr  %o0                                       
4001eda8:	7f ff d8 bf 	call  400150a4 <rtems_rfs_trace>               
4001edac:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
4001edb0:	80 8a 20 ff 	btst  0xff, %o0                                
4001edb4:	32 80 00 27 	bne,a   4001ee50 <rtems_rfs_dir_read+0xb0>     <== NEVER TAKEN
4001edb8:	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;                                                        
4001edbc:	c0 27 40 00 	clr  [ %i5 ]                                   
                                                                      
  rc = rtems_rfs_block_map_open (fs, dir, &map);                      
4001edc0:	90 10 00 18 	mov  %i0, %o0                                  
4001edc4:	92 10 00 19 	mov  %i1, %o1                                  
4001edc8:	7f ff f6 92 	call  4001c810 <rtems_rfs_block_map_open>      
4001edcc:	94 07 bf b0 	add  %fp, -80, %o2                             
  if (rc > 0)                                                         
4001edd0:	a0 92 20 00 	orcc  %o0, 0, %l0                              
4001edd4:	24 80 00 04 	ble,a   4001ede4 <rtems_rfs_dir_read+0x44>     <== ALWAYS TAKEN
4001edd8:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
  return rc;                                                          
}                                                                     
4001eddc:	81 c7 e0 08 	ret                                            
4001ede0:	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))
4001ede4:	90 10 00 1a 	mov  %i2, %o0                                  
4001ede8:	a2 10 00 10 	mov  %l0, %l1                                  
4001edec:	92 10 00 1b 	mov  %i3, %o1                                  
4001edf0:	a0 10 20 00 	clr  %l0                                       
4001edf4:	96 10 00 11 	mov  %l1, %o3                                  
4001edf8:	40 00 4c 40 	call  40031ef8 <__moddi3>                      
4001edfc:	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) -                                
4001ee00:	92 a4 40 09 	subcc  %l1, %o1, %o1                           
4001ee04:	90 64 00 08 	subx  %l0, %o0, %o0                            
4001ee08:	80 a2 20 00 	cmp  %o0, 0                                    
4001ee0c:	04 80 00 18 	ble  4001ee6c <rtems_rfs_dir_read+0xcc>        <== ALWAYS TAKEN
4001ee10:	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);           
4001ee14:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001ee18:	92 07 bf b0 	add  %fp, -80, %o1                             
4001ee1c:	94 10 00 1a 	mov  %i2, %o2                                  
4001ee20:	96 10 00 1b 	mov  %i3, %o3                                  
4001ee24:	7f ff f7 aa 	call  4001cccc <rtems_rfs_block_map_seek>      
4001ee28:	98 07 bf a0 	add  %fp, -96, %o4                             
  if (rc > 0)                                                         
4001ee2c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
4001ee30:	04 80 00 25 	ble  4001eec4 <rtems_rfs_dir_read+0x124>       <== ALWAYS TAKEN
4001ee34:	80 a4 20 06 	cmp  %l0, 6                                    
  {                                                                   
    if (rc == ENXIO)                                                  
4001ee38:	02 80 00 1f 	be  4001eeb4 <rtems_rfs_dir_read+0x114>        <== NOT EXECUTED
4001ee3c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      rc = ENOENT;                                                    
    rtems_rfs_block_map_close (fs, &map);                             
4001ee40:	7f ff f6 d5 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001ee44:	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;                                                          
}                                                                     
4001ee48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ee4c:	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",
4001ee50:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001ee54:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001ee58:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
4001ee5c:	40 00 18 c8 	call  4002517c <printf>                        <== NOT EXECUTED
4001ee60:	90 12 21 e8 	or  %o0, 0x1e8, %o0                            <== NOT EXECUTED
            rtems_rfs_inode_ino (dir), offset);                       
                                                                      
  *length = 0;                                                        
4001ee64:	10 bf ff d7 	b  4001edc0 <rtems_rfs_dir_read+0x20>          <== NOT EXECUTED
4001ee68:	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) -                                
4001ee6c:	32 80 00 06 	bne,a   4001ee84 <rtems_rfs_dir_read+0xe4>     <== NEVER TAKEN
4001ee70:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4001ee74:	80 a2 60 0a 	cmp  %o1, 0xa                                  
4001ee78:	38 bf ff e8 	bgu,a   4001ee18 <rtems_rfs_dir_read+0x78>     <== ALWAYS TAKEN
4001ee7c:	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) *         
4001ee80:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4001ee84:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001ee88:	94 10 00 10 	mov  %l0, %o2                                  <== NOT EXECUTED
4001ee8c:	40 00 4b 30 	call  40031b4c <__divdi3>                      <== NOT EXECUTED
4001ee90:	96 10 00 11 	mov  %l1, %o3                                  <== NOT EXECUTED
4001ee94:	96 82 60 01 	addcc  %o1, 1, %o3                             <== NOT EXECUTED
4001ee98:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4001ee9c:	94 42 20 00 	addx  %o0, 0, %o2                              <== NOT EXECUTED
4001eea0:	40 00 4a f9 	call  40031a84 <__muldi3>                      <== NOT EXECUTED
4001eea4:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001eea8:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
4001eeac:	10 bf ff da 	b  4001ee14 <rtems_rfs_dir_read+0x74>          <== NOT EXECUTED
4001eeb0:	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;                                                    
4001eeb4:	a0 10 20 02 	mov  2, %l0                                    <== NOT EXECUTED
    rtems_rfs_block_map_close (fs, &map);                             
4001eeb8:	7f ff f6 b7 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
4001eebc:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001eec0:	30 bf ff e2 	b,a   4001ee48 <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)                         
4001eec4:	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",
4001eec8:	2b 10 00 e2 	sethi  %hi(0x40038800), %l5                    
 */                                                                   
static inline int                                                     
rtems_rfs_buffer_handle_open (rtems_rfs_file_system*   fs,            
                              rtems_rfs_buffer_handle* handle)        
{                                                                     
  handle->dirty = false;                                              
4001eecc:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001eed0:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001eed4:	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)                         
4001eed8:	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",
4001eedc:	aa 15 62 98 	or  %l5, 0x298, %l5                            
    uint8_t*      entry;                                              
    rtems_rfs_ino eino;                                               
    int           elength;                                            
    int           remaining;                                          
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);  
4001eee0:	d4 07 bf a0 	ld  [ %fp + -96 ], %o2                         
4001eee4:	96 10 20 01 	mov  1, %o3                                    
4001eee8:	92 07 bf a4 	add  %fp, -92, %o1                             
4001eeec:	7f ff fa 4d 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001eef0:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc > 0)                                                       
4001eef4:	a0 92 20 00 	orcc  %o0, 0, %l0                              
4001eef8:	14 80 00 32 	bg  4001efc0 <rtems_rfs_dir_read+0x220>        <== NEVER TAKEN
4001eefc:	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;                                           
4001ef00:	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);                         
4001ef04:	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))                   
4001ef08:	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;                                           
4001ef0c:	a2 00 40 12 	add  %g1, %l2, %l1                             
                                                                      
    elength = rtems_rfs_dir_entry_length (entry);                     
4001ef10:	c4 0c 60 09 	ldub  [ %l1 + 9 ], %g2                         
4001ef14:	e6 0c 60 08 	ldub  [ %l1 + 8 ], %l3                         
    eino    = rtems_rfs_dir_entry_ino (entry);                        
4001ef18:	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);                     
4001ef1c:	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))                   
4001ef20:	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);                     
4001ef24:	a6 14 c0 02 	or  %l3, %g2, %l3                              
    eino    = rtems_rfs_dir_entry_ino (entry);                        
4001ef28:	c6 0c 60 01 	ldub  [ %l1 + 1 ], %g3                         
4001ef2c:	c2 0c 60 02 	ldub  [ %l1 + 2 ], %g1                         
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
4001ef30:	80 a4 c0 14 	cmp  %l3, %l4                                  
4001ef34:	12 80 00 2d 	bne  4001efe8 <rtems_rfs_dir_read+0x248>       
4001ef38:	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;          
4001ef3c:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
4001ef40:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001ef44:	a4 20 80 12 	sub  %g2, %l2, %l2                             
4001ef48:	a4 00 40 12 	add  %g1, %l2, %l2                             
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                   
4001ef4c:	7f ff d8 56 	call  400150a4 <rtems_rfs_trace>               
4001ef50:	e4 27 40 00 	st  %l2, [ %i5 ]                               
4001ef54:	80 8a 20 ff 	btst  0xff, %o0                                
4001ef58:	12 80 00 0d 	bne  4001ef8c <rtems_rfs_dir_read+0x1ec>       <== NEVER TAKEN
4001ef5c:	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);           
4001ef60:	92 07 bf b0 	add  %fp, -80, %o1                             
4001ef64:	7f ff f7 77 	call  4001cd40 <rtems_rfs_block_map_next_block>
4001ef68:	94 07 bf a0 	add  %fp, -96, %o2                             
    if (rc == ENXIO)                                                  
4001ef6c:	80 a2 20 06 	cmp  %o0, 6                                    
4001ef70:	02 80 00 13 	be  4001efbc <rtems_rfs_dir_read+0x21c>        <== ALWAYS TAKEN
4001ef74:	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)                                                     
4001ef78:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001ef7c:	02 bf ff da 	be  4001eee4 <rtems_rfs_dir_read+0x144>        <== NOT EXECUTED
4001ef80:	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);                       
4001ef84:	10 80 00 10 	b  4001efc4 <rtems_rfs_dir_read+0x224>         <== NOT EXECUTED
4001ef88:	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",
4001ef8c:	d6 07 40 00 	ld  [ %i5 ], %o3                               <== NOT EXECUTED
4001ef90:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
4001ef94:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
4001ef98:	40 00 18 79 	call  4002517c <printf>                        <== NOT EXECUTED
4001ef9c:	90 10 00 15 	mov  %l5, %o0                                  <== NOT EXECUTED
              offset, *length);                                       
                                                                      
    rc = rtems_rfs_block_map_next_block (fs, &map, &block);           
4001efa0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001efa4:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
4001efa8:	7f ff f7 66 	call  4001cd40 <rtems_rfs_block_map_next_block><== NOT EXECUTED
4001efac:	94 07 bf a0 	add  %fp, -96, %o2                             <== NOT EXECUTED
    if (rc == ENXIO)                                                  
4001efb0:	80 a2 20 06 	cmp  %o0, 6                                    <== NOT EXECUTED
4001efb4:	12 bf ff f1 	bne  4001ef78 <rtems_rfs_dir_read+0x1d8>       <== NOT EXECUTED
4001efb8:	a0 10 00 08 	mov  %o0, %l0                                  <== NOT EXECUTED
      rc = ENOENT;                                                    
4001efbc:	a0 10 20 02 	mov  2, %l0                                    
4001efc0:	92 07 bf a4 	add  %fp, -92, %o1                             
4001efc4:	7f ff f9 9d 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001efc8:	90 10 00 18 	mov  %i0, %o0                                  
  }                                                                   
                                                                      
  rtems_rfs_buffer_handle_close (fs, &buffer);                        
  rtems_rfs_block_map_close (fs, &map);                               
4001efcc:	90 10 00 18 	mov  %i0, %o0                                  
  handle->dirty = false;                                              
4001efd0:	c0 2f bf a4 	clrb  [ %fp + -92 ]                            
  handle->bnum  = 0;                                                  
4001efd4:	c0 27 bf a8 	clr  [ %fp + -88 ]                             
  handle->buffer = NULL;                                              
4001efd8:	c0 27 bf ac 	clr  [ %fp + -84 ]                             
4001efdc:	7f ff f6 6e 	call  4001c994 <rtems_rfs_block_map_close>     
4001efe0:	92 07 bf b0 	add  %fp, -80, %o1                             
4001efe4:	30 bf ff 7e 	b,a   4001eddc <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);                        
4001efe8:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4001efec:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
4001eff0:	84 08 a0 ff 	and  %g2, 0xff, %g2                            
4001eff4:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001eff8:	82 08 60 ff 	and  %g1, 0xff, %g1                            
4001effc:	88 11 00 03 	or  %g4, %g3, %g4                              
4001f000:	83 28 60 08 	sll  %g1, 8, %g1                               
4001f004:	84 11 00 02 	or  %g4, %g2, %g2                              
                                                                      
    if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)                         
    {                                                                 
      if (rtems_rfs_dir_entry_valid (fs, elength, eino))              
4001f008:	80 a4 e0 0a 	cmp  %l3, 0xa                                  
4001f00c:	04 80 00 0d 	ble  4001f040 <rtems_rfs_dir_read+0x2a0>       <== NEVER TAKEN
4001f010:	a8 10 80 01 	or  %g2, %g1, %l4                              
4001f014:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
4001f018:	80 a4 c0 01 	cmp  %l3, %g1                                  
4001f01c:	1a 80 00 0a 	bcc  4001f044 <rtems_rfs_dir_read+0x2a4>       <== NEVER TAKEN
4001f020:	90 10 20 00 	clr  %o0                                       
4001f024:	80 a5 20 00 	cmp  %l4, 0                                    
4001f028:	02 80 00 08 	be  4001f048 <rtems_rfs_dir_read+0x2a8>        <== NEVER TAKEN
4001f02c:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
4001f030:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
4001f034:	80 a5 00 01 	cmp  %l4, %g1                                  
4001f038:	08 80 00 12 	bleu  4001f080 <rtems_rfs_dir_read+0x2e0>      <== ALWAYS TAKEN
4001f03c:	90 10 00 1c 	mov  %i4, %o0                                  
      {                                                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))               
4001f040:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001f044:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    <== NOT EXECUTED
4001f048:	7f ff d8 17 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f04c:	a0 10 20 05 	mov  5, %l0                                    <== NOT EXECUTED
4001f050:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f054:	22 bf ff dc 	be,a   4001efc4 <rtems_rfs_dir_read+0x224>     <== NOT EXECUTED
4001f058:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
          printf ("rtems-rfs: dir-read: "                             
4001f05c:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
4001f060:	d8 07 bf c4 	ld  [ %fp + -60 ], %o4                         <== NOT EXECUTED
4001f064:	94 10 00 13 	mov  %l3, %o2                                  <== NOT EXECUTED
4001f068:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001f06c:	96 10 00 14 	mov  %l4, %o3                                  <== NOT EXECUTED
4001f070:	40 00 18 43 	call  4002517c <printf>                        <== NOT EXECUTED
4001f074:	90 12 22 18 	or  %o0, 0x218, %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);                       
4001f078:	10 bf ff d3 	b  4001efc4 <rtems_rfs_dir_read+0x224>         <== NOT EXECUTED
4001f07c:	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));                     
4001f080:	92 10 20 00 	clr  %o1                                       
4001f084:	40 00 17 c0 	call  40024f84 <memset>                        
4001f088:	94 10 21 18 	mov  0x118, %o2                                
      dirent->d_off = offset;                                         
      dirent->d_reclen = sizeof (struct dirent);                      
                                                                      
      *length += elength;                                             
4001f08c:	c2 07 40 00 	ld  [ %i5 ], %g1                               
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
      dirent->d_off = offset;                                         
      dirent->d_reclen = sizeof (struct dirent);                      
4001f090:	84 10 21 18 	mov  0x118, %g2                                
        rc = EIO;                                                     
        break;                                                        
      }                                                               
                                                                      
      memset (dirent, 0, sizeof (struct dirent));                     
      dirent->d_off = offset;                                         
4001f094:	f4 3f 20 08 	std  %i2, [ %i4 + 8 ]                          
      dirent->d_reclen = sizeof (struct dirent);                      
4001f098:	c4 37 20 10 	sth  %g2, [ %i4 + 0x10 ]                       
                                                                      
      *length += elength;                                             
4001f09c:	82 04 c0 01 	add  %l3, %g1, %g1                             
4001f0a0:	c2 27 40 00 	st  %g1, [ %i5 ]                               
                                                                      
      remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
4001f0a4:	c4 06 20 08 	ld  [ %i0 + 8 ], %g2                           
4001f0a8:	84 20 80 12 	sub  %g2, %l2, %g2                             
4001f0ac:	84 20 80 13 	sub  %g2, %l3, %g2                             
                                                                      
      if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)                      
4001f0b0:	80 a0 a0 0a 	cmp  %g2, 0xa                                  
4001f0b4:	14 80 00 04 	bg  4001f0c4 <rtems_rfs_dir_read+0x324>        <== ALWAYS TAKEN
4001f0b8:	a6 04 ff f6 	add  %l3, -10, %l3                             
        *length += remaining;                                         
4001f0bc:	82 00 80 01 	add  %g2, %g1, %g1                             <== NOT EXECUTED
4001f0c0:	c2 27 40 00 	st  %g1, [ %i5 ]                               <== NOT EXECUTED
4001f0c4:	80 a4 e0 ff 	cmp  %l3, 0xff                                 
4001f0c8:	34 80 00 02 	bg,a   4001f0d0 <rtems_rfs_dir_read+0x330>     <== NEVER TAKEN
4001f0cc:	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);
4001f0d0:	92 04 60 0a 	add  %l1, 0xa, %o1                             
4001f0d4:	94 10 00 13 	mov  %l3, %o2                                  
4001f0d8:	ba 07 20 14 	add  %i4, 0x14, %i5                            
4001f0dc:	40 00 17 1b 	call  40024d48 <memcpy>                        
4001f0e0:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
      dirent->d_ino = rtems_rfs_dir_entry_ino (entry);                
4001f0e4:	c8 0c 40 00 	ldub  [ %l1 ], %g4                             
4001f0e8:	c6 0c 60 01 	ldub  [ %l1 + 1 ], %g3                         
4001f0ec:	c4 0c 60 03 	ldub  [ %l1 + 3 ], %g2                         
4001f0f0:	c2 0c 60 02 	ldub  [ %l1 + 2 ], %g1                         
4001f0f4:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4001f0f8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001f0fc:	83 28 60 08 	sll  %g1, 8, %g1                               
4001f100:	86 11 00 03 	or  %g4, %g3, %g3                              
4001f104:	84 10 c0 02 	or  %g3, %g2, %g2                              
4001f108:	82 10 80 01 	or  %g2, %g1, %g1                              
      dirent->d_namlen = elength;                                     
4001f10c:	e6 37 20 12 	sth  %l3, [ %i4 + 0x12 ]                       
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))                 
4001f110:	90 10 20 00 	clr  %o0                                       
4001f114:	13 20 00 00 	sethi  %hi(0x80000000), %o1                    
4001f118:	7f ff d7 e3 	call  400150a4 <rtems_rfs_trace>               
4001f11c:	c2 27 00 00 	st  %g1, [ %i4 ]                               
4001f120:	80 8a 20 ff 	btst  0xff, %o0                                
4001f124:	22 bf ff a8 	be,a   4001efc4 <rtems_rfs_dir_read+0x224>     <== ALWAYS TAKEN
4001f128:	92 07 bf a4 	add  %fp, -92, %o1                             
        printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
4001f12c:	c4 1f 20 08 	ldd  [ %i4 + 8 ], %g2                          <== NOT EXECUTED
4001f130:	d6 07 00 00 	ld  [ %i4 ], %o3                               <== NOT EXECUTED
4001f134:	92 10 00 02 	mov  %g2, %o1                                  <== NOT EXECUTED
4001f138:	94 10 00 03 	mov  %g3, %o2                                  <== NOT EXECUTED
4001f13c:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001f140:	98 10 00 1d 	mov  %i5, %o4                                  <== NOT EXECUTED
4001f144:	40 00 18 0e 	call  4002517c <printf>                        <== NOT EXECUTED
4001f148:	90 12 22 60 	or  %o0, 0x260, %o0                            <== NOT EXECUTED
4001f14c:	10 bf ff 9e 	b  4001efc4 <rtems_rfs_dir_read+0x224>         <== NOT EXECUTED
4001f150:	92 07 bf a4 	add  %fp, -92, %o1                             <== NOT EXECUTED
                                                                      

4001f724 <rtems_rfs_file_close>: } int rtems_rfs_file_close (rtems_rfs_file_system* fs, rtems_rfs_file_handle* handle) {
4001f724:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rrc;                                                            
  int rc;                                                             
                                                                      
  rrc = 0;                                                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                   
4001f728:	90 10 20 10 	mov  0x10, %o0                                 
4001f72c:	92 10 20 00 	clr  %o1                                       
4001f730:	7f ff d6 5d 	call  400150a4 <rtems_rfs_trace>               
4001f734:	ba 10 00 18 	mov  %i0, %i5                                  
4001f738:	80 8a 20 ff 	btst  0xff, %o0                                
4001f73c:	32 80 00 87 	bne,a   4001f958 <rtems_rfs_file_close+0x234>  <== NEVER TAKEN
4001f740:	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)                                 
4001f744:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
4001f748:	c2 02 60 08 	ld  [ %o1 + 8 ], %g1                           
4001f74c:	80 a0 60 00 	cmp  %g1, 0                                    
4001f750:	04 80 00 04 	ble  4001f760 <rtems_rfs_file_close+0x3c>      <== NEVER TAKEN
4001f754:	82 00 7f ff 	add  %g1, -1, %g1                              
    handle->shared->references--;                                     
4001f758:	c2 22 60 08 	st  %g1, [ %o1 + 8 ]                           
                                                                      
  if (handle->shared->references == 0)                                
4001f75c:	80 a0 60 00 	cmp  %g1, 0                                    
4001f760:	12 80 00 74 	bne  4001f930 <rtems_rfs_file_close+0x20c>     <== NEVER TAKEN
4001f764:	90 10 00 1d 	mov  %i5, %o0                                  
  {                                                                   
    if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))          
4001f768:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
4001f76c:	80 a0 60 00 	cmp  %g1, 0                                    
4001f770:	22 80 00 a7 	be,a   4001fa0c <rtems_rfs_file_close+0x2e8>   <== ALWAYS TAKEN
4001f774:	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,              
4001f778:	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);                      
4001f77c:	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);                  
4001f780:	89 30 a0 18 	srl  %g2, 0x18, %g4                            
4001f784:	c8 28 60 10 	stb  %g4, [ %g1 + 0x10 ]                       
4001f788:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
4001f78c:	89 30 a0 10 	srl  %g2, 0x10, %g4                            
4001f790:	c8 28 60 11 	stb  %g4, [ %g1 + 0x11 ]                       
4001f794:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
4001f798:	89 30 a0 08 	srl  %g2, 8, %g4                               
4001f79c:	c8 28 60 12 	stb  %g4, [ %g1 + 0x12 ]                       
4001f7a0:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
4001f7a4:	c4 28 60 13 	stb  %g2, [ %g1 + 0x13 ]                       
                                 handle->shared->atime);              
      rtems_rfs_inode_set_mtime (&handle->shared->inode,              
4001f7a8:	c4 06 60 1c 	ld  [ %i1 + 0x1c ], %g2                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001f7ac:	c6 2a 60 1c 	stb  %g3, [ %o1 + 0x1c ]                       
4001f7b0:	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);                  
4001f7b4:	c8 00 a0 18 	ld  [ %g2 + 0x18 ], %g4                        
4001f7b8:	b9 30 60 18 	srl  %g1, 0x18, %i4                            
4001f7bc:	f8 29 20 14 	stb  %i4, [ %g4 + 0x14 ]                       
4001f7c0:	c8 00 a0 18 	ld  [ %g2 + 0x18 ], %g4                        
4001f7c4:	b9 30 60 10 	srl  %g1, 0x10, %i4                            
4001f7c8:	f8 29 20 15 	stb  %i4, [ %g4 + 0x15 ]                       
4001f7cc:	c8 00 a0 18 	ld  [ %g2 + 0x18 ], %g4                        
4001f7d0:	b9 30 60 08 	srl  %g1, 8, %i4                               
4001f7d4:	f8 29 20 16 	stb  %i4, [ %g4 + 0x16 ]                       
4001f7d8:	c8 00 a0 18 	ld  [ %g2 + 0x18 ], %g4                        
4001f7dc:	c2 29 20 17 	stb  %g1, [ %g4 + 0x17 ]                       
                                 handle->shared->mtime);              
      rtems_rfs_inode_set_ctime (&handle->shared->inode,              
4001f7e0:	c2 06 60 1c 	ld  [ %i1 + 0x1c ], %g1                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001f7e4:	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);                  
4001f7e8:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4001f7ec:	c4 00 60 94 	ld  [ %g1 + 0x94 ], %g2                        
4001f7f0:	b9 30 a0 18 	srl  %g2, 0x18, %i4                            
4001f7f4:	f8 29 20 18 	stb  %i4, [ %g4 + 0x18 ]                       
4001f7f8:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4001f7fc:	b9 30 a0 10 	srl  %g2, 0x10, %i4                            
4001f800:	f8 29 20 19 	stb  %i4, [ %g4 + 0x19 ]                       
4001f804:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4001f808:	b9 30 a0 08 	srl  %g2, 8, %i4                               
4001f80c:	f8 29 20 1a 	stb  %i4, [ %g4 + 0x1a ]                       
4001f810:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        
4001f814:	c4 29 20 1b 	stb  %g2, [ %g4 + 0x1b ]                       
                                 handle->shared->ctime);              
      if (!rtems_rfs_block_size_equal (&handle->shared->size,         
4001f818:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001f81c:	c6 28 60 1c 	stb  %g3, [ %g1 + 0x1c ]                       
4001f820:	c4 02 60 3c 	ld  [ %o1 + 0x3c ], %g2                        
4001f824:	c2 02 60 84 	ld  [ %o1 + 0x84 ], %g1                        
4001f828:	80 a0 40 02 	cmp  %g1, %g2                                  
4001f82c:	02 80 00 72 	be  4001f9f4 <rtems_rfs_file_close+0x2d0>      <== ALWAYS TAKEN
4001f830:	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);                       
4001f834:	c2 22 60 3c 	st  %g1, [ %o1 + 0x3c ]                        <== NOT EXECUTED
4001f838:	c4 22 60 40 	st  %g2, [ %o1 + 0x40 ]                        <== NOT EXECUTED
  map->dirty = true;                                                  
4001f83c:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4001f840:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4001f844:	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);        
4001f848:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001f84c:	7f ff f4 52 	call  4001c994 <rtems_rfs_block_map_close>     
4001f850:	92 02 60 34 	add  %o1, 0x34, %o1                            
    if (rc > 0)                                                       
4001f854:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4001f858:	04 80 00 0a 	ble  4001f880 <rtems_rfs_file_close+0x15c>     <== ALWAYS TAKEN
4001f85c:	90 10 20 10 	mov  0x10, %o0                                 
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
4001f860:	7f ff d6 11 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f864:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001f868:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f86c:	32 80 00 57 	bne,a   4001f9c8 <rtems_rfs_file_close+0x2a4>  <== NOT EXECUTED
4001f870:	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)                                                   
4001f874:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
4001f878:	22 80 00 02 	be,a   4001f880 <rtems_rfs_file_close+0x15c>   <== NOT EXECUTED
4001f87c:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rc = rtems_rfs_inode_close (fs, &handle->shared->inode);          
4001f880:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
4001f884:	90 10 00 1d 	mov  %i5, %o0                                  
4001f888:	7f ff cf d8 	call  400137e8 <rtems_rfs_inode_close>         
4001f88c:	92 02 60 0c 	add  %o1, 0xc, %o1                             
    if (rc > 0)                                                       
4001f890:	b8 92 20 00 	orcc  %o0, 0, %i4                              
4001f894:	04 80 00 0a 	ble  4001f8bc <rtems_rfs_file_close+0x198>     <== ALWAYS TAKEN
4001f898:	90 10 20 10 	mov  0x10, %o0                                 
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))               
4001f89c:	7f ff d6 02 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f8a0:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001f8a4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f8a8:	32 80 00 3d 	bne,a   4001f99c <rtems_rfs_file_close+0x278>  <== NOT EXECUTED
4001f8ac:	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)                                                   
4001f8b0:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
4001f8b4:	22 80 00 2f 	be,a   4001f970 <rtems_rfs_file_close+0x24c>   <== NOT EXECUTED
4001f8b8:	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 );                                         
4001f8bc:	7f ff ea e8 	call  4001a45c <_Chain_Extract>                
4001f8c0:	d0 06 60 1c 	ld  [ %i1 + 0x1c ], %o0                        
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rtems_chain_extract (&handle->shared->link);                      
    free (handle->shared);                                            
4001f8c4:	7f ff a6 19 	call  40009128 <free>                          
4001f8c8:	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);                       
4001f8cc:	90 10 00 1d 	mov  %i5, %o0                                  
4001f8d0:	7f ff f7 5a 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001f8d4:	92 06 60 04 	add  %i1, 4, %o1                               
  handle->dirty = false;                                              
4001f8d8:	c0 2e 60 04 	clrb  [ %i1 + 4 ]                              
  handle->bnum  = 0;                                                  
4001f8dc:	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)                                                        
4001f8e0:	80 a6 20 00 	cmp  %i0, 0                                    
4001f8e4:	04 80 00 19 	ble  4001f948 <rtems_rfs_file_close+0x224>     <== ALWAYS TAKEN
4001f8e8:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))                 
4001f8ec:	90 10 20 10 	mov  0x10, %o0                                 <== NOT EXECUTED
4001f8f0:	7f ff d5 ed 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f8f4:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001f8f8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f8fc:	02 80 00 13 	be  4001f948 <rtems_rfs_file_close+0x224>      <== NOT EXECUTED
4001f900:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
4001f904:	40 00 1a 68 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001f908:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001f90c:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001f910:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001f914:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001f918:	40 00 16 19 	call  4002517c <printf>                        <== NOT EXECUTED
4001f91c:	90 12 20 c8 	or  %o0, 0xc8, %o0	! 40038cc8 <CSWTCH.2+0xed8> <== NOT EXECUTED
  }                                                                   
                                                                      
  free (handle);                                                      
4001f920:	7f ff a6 02 	call  40009128 <free>                          <== NOT EXECUTED
4001f924:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
4001f928:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001f92c:	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);                       
4001f930:	92 06 60 04 	add  %i1, 4, %o1                               <== NOT EXECUTED
4001f934:	7f ff f7 41 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f938:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  handle->dirty = false;                                              
4001f93c:	c0 2e 60 04 	clrb  [ %i1 + 4 ]                              <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001f940:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001f944:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             <== NOT EXECUTED
4001f948:	7f ff a5 f8 	call  40009128 <free>                          
4001f94c:	90 10 00 19 	mov  %i1, %o0                                  
4001f950:	81 c7 e0 08 	ret                                            
4001f954:	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",        
4001f958:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001f95c:	d2 00 60 14 	ld  [ %g1 + 0x14 ], %o1                        <== NOT EXECUTED
4001f960:	40 00 16 07 	call  4002517c <printf>                        <== NOT EXECUTED
4001f964:	90 12 20 20 	or  %o0, 0x20, %o0                             <== NOT EXECUTED
            handle->shared->inode.ino);                               
                                                                      
  if (handle->shared->references > 0)                                 
4001f968:	10 bf ff 78 	b  4001f748 <rtems_rfs_file_close+0x24>        <== NOT EXECUTED
4001f96c:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        <== NOT EXECUTED
4001f970:	7f ff ea bb 	call  4001a45c <_Chain_Extract>                <== NOT EXECUTED
4001f974:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
      if (rrc == 0)                                                   
        rrc = rc;                                                     
    }                                                                 
                                                                      
    rtems_chain_extract (&handle->shared->link);                      
    free (handle->shared);                                            
4001f978:	7f ff a5 ec 	call  40009128 <free>                          <== NOT EXECUTED
4001f97c:	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);                       
4001f980:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4001f984:	7f ff f7 2d 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f988:	92 06 60 04 	add  %i1, 4, %o1                               <== NOT EXECUTED
  handle->dirty = false;                                              
4001f98c:	c0 2e 60 04 	clrb  [ %i1 + 4 ]                              <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001f990:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
  handle->buffer = NULL;                                              
4001f994:	10 bf ff d6 	b  4001f8ec <rtems_rfs_file_close+0x1c8>       <== NOT EXECUTED
4001f998:	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",
4001f99c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4001f9a0:	40 00 1a 41 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001f9a4:	f6 00 60 14 	ld  [ %g1 + 0x14 ], %i3                        <== NOT EXECUTED
4001f9a8:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001f9ac:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001f9b0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
4001f9b4:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001f9b8:	40 00 15 f1 	call  4002517c <printf>                        <== NOT EXECUTED
4001f9bc:	90 12 20 88 	or  %o0, 0x88, %o0	! 40038c88 <CSWTCH.2+0xe98> <== NOT EXECUTED
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
4001f9c0:	10 bf ff bd 	b  4001f8b4 <rtems_rfs_file_close+0x190>       <== NOT EXECUTED
4001f9c4:	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",
4001f9c8:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4001f9cc:	40 00 1a 36 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001f9d0:	f6 00 60 14 	ld  [ %g1 + 0x14 ], %i3                        <== NOT EXECUTED
4001f9d4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
4001f9d8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001f9dc:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
4001f9e0:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001f9e4:	40 00 15 e6 	call  4002517c <printf>                        <== NOT EXECUTED
4001f9e8:	90 12 20 48 	or  %o0, 0x48, %o0	! 40038c48 <CSWTCH.2+0xe58> <== NOT EXECUTED
                handle->shared->inode.ino, rc, strerror (rc));        
      if (rrc == 0)                                                   
4001f9ec:	10 bf ff a3 	b  4001f878 <rtems_rfs_file_close+0x154>       <== NOT EXECUTED
4001f9f0:	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,         
4001f9f4:	c6 02 60 40 	ld  [ %o1 + 0x40 ], %g3                        
4001f9f8:	80 a0 80 03 	cmp  %g2, %g3                                  
4001f9fc:	12 bf ff 8e 	bne  4001f834 <rtems_rfs_file_close+0x110>     <== NEVER TAKEN
4001fa00:	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);        
4001fa04:	10 bf ff 92 	b  4001f84c <rtems_rfs_file_close+0x128>       
4001fa08:	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);        
4001fa0c:	7f ff ce d2 	call  40013554 <rtems_rfs_inode_load>          
4001fa10:	90 10 00 1d 	mov  %i5, %o0                                  
4001fa14:	d2 06 60 1c 	ld  [ %i1 + 0x1c ], %o1                        
                                                                      
    if (rrc == 0)                                                     
4001fa18:	80 a2 20 00 	cmp  %o0, 0                                    
4001fa1c:	12 bf ff 8b 	bne  4001f848 <rtems_rfs_file_close+0x124>     <== NEVER TAKEN
4001fa20:	b0 10 00 08 	mov  %o0, %i0                                  
4001fa24:	10 bf ff 55 	b  4001f778 <rtems_rfs_file_close+0x54>        
4001fa28:	c2 02 60 18 	ld  [ %o1 + 0x18 ], %g1                        
                                                                      

400203d4 <rtems_rfs_file_get_shared>: */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First( Chain_Control *the_chain ) { return _Chain_Head( the_chain )->next;
400203d4:	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 ));            
400203d8:	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))               
400203dc:	80 a0 40 08 	cmp  %g1, %o0                                  
400203e0:	32 80 00 08 	bne,a   40020400 <rtems_rfs_file_get_shared+0x2c>
400203e4:	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;                                                        
400203e8:	81 c3 e0 08 	retl                                           
400203ec:	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))               
400203f0:	80 a0 40 08 	cmp  %g1, %o0                                  
400203f4:	22 80 00 08 	be,a   40020414 <rtems_rfs_file_get_shared+0x40><== ALWAYS TAKEN
400203f8:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    rtems_rfs_file_shared* shared;                                    
    shared = (rtems_rfs_file_shared*) node;                           
    if (shared->inode.ino == ino)                                     
400203fc:	c4 00 60 14 	ld  [ %g1 + 0x14 ], %g2                        <== NOT EXECUTED
40020400:	80 a0 80 09 	cmp  %g2, %o1                                  
40020404:	32 bf ff fb 	bne,a   400203f0 <rtems_rfs_file_get_shared+0x1c>
40020408:	c2 00 40 00 	ld  [ %g1 ], %g1                               
      return shared;                                                  
    node = rtems_chain_next (node);                                   
  }                                                                   
  return NULL;                                                        
}                                                                     
4002040c:	81 c3 e0 08 	retl                                           
40020410:	90 10 00 01 	mov  %g1, %o0                                  
40020414:	81 c3 e0 08 	retl                                           
                                                                      

4001fc70 <rtems_rfs_file_io_end>: int rtems_rfs_file_io_end (rtems_rfs_file_handle* handle, size_t size, bool read) {
4001fc70:	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))                      
4001fc74:	90 10 20 20 	mov  0x20, %o0                                 
4001fc78:	92 10 20 00 	clr  %o1                                       
4001fc7c:	7f ff d5 0a 	call  400150a4 <rtems_rfs_trace>               
4001fc80:	ba 10 00 18 	mov  %i0, %i5                                  
4001fc84:	80 8a 20 ff 	btst  0xff, %o0                                
4001fc88:	22 80 00 0c 	be,a   4001fcb8 <rtems_rfs_file_io_end+0x48>   <== ALWAYS TAKEN
4001fc8c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    printf ("rtems-rfs: file-io:   end: %s size=%zu\n",               
4001fc90:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4001fc94:	12 80 00 22 	bne  4001fd1c <rtems_rfs_file_io_end+0xac>     <== NOT EXECUTED
4001fc98:	13 10 00 dd 	sethi  %hi(0x40037400), %o1                    <== NOT EXECUTED
4001fc9c:	13 10 00 e3 	sethi  %hi(0x40038c00), %o1                    <== NOT EXECUTED
4001fca0:	92 12 60 f0 	or  %o1, 0xf0, %o1	! 40038cf0 <CSWTCH.2+0xf00> <== NOT EXECUTED
4001fca4:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001fca8:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
4001fcac:	40 00 15 34 	call  4002517c <printf>                        <== NOT EXECUTED
4001fcb0:	90 12 21 b0 	or  %o0, 0x1b0, %o0                            <== NOT EXECUTED
            read ? "read" : "write", size);                           
                                                                      
  if (rtems_rfs_buffer_handle_has_block (&handle->buffer))            
4001fcb4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
4001fcb8:	80 a0 60 00 	cmp  %g1, 0                                    
4001fcbc:	02 80 00 1a 	be  4001fd24 <rtems_rfs_file_io_end+0xb4>      <== NEVER TAKEN
4001fcc0:	80 a6 a0 00 	cmp  %i2, 0                                    
  {                                                                   
    if (!read)                                                        
4001fcc4:	12 80 00 8b 	bne  4001fef0 <rtems_rfs_file_io_end+0x280>    
4001fcc8:	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), 
4001fccc:	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));   
4001fcd0:	82 10 20 01 	mov  1, %g1                                    
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
4001fcd4:	92 07 60 04 	add  %i5, 4, %o1                               
4001fcd8:	7f ff f6 58 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001fcdc:	c2 2f 60 04 	stb  %g1, [ %i5 + 4 ]                          
                                          rtems_rfs_file_buffer (handle));
    if (rc > 0)                                                       
4001fce0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001fce4:	04 80 00 11 	ble  4001fd28 <rtems_rfs_file_io_end+0xb8>     <== ALWAYS TAKEN
4001fce8:	39 10 00 e3 	sethi  %hi(0x40038c00), %i4                    
    {                                                                 
      printf (                                                        
4001fcec:	b8 17 20 f0 	or  %i4, 0xf0, %i4	! 40038cf0 <CSWTCH.2+0xf00> <== NOT EXECUTED
4001fcf0:	40 00 19 6d 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001fcf4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001fcf8:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001fcfc:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
4001fd00:	94 10 00 19 	mov  %i1, %o2                                  <== NOT EXECUTED
4001fd04:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001fd08:	96 10 00 18 	mov  %i0, %o3                                  <== NOT EXECUTED
4001fd0c:	40 00 15 1c 	call  4002517c <printf>                        <== NOT EXECUTED
4001fd10:	90 12 21 d8 	or  %o0, 0x1d8, %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;                                                      
4001fd14:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001fd18:	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",               
4001fd1c:	10 bf ff e2 	b  4001fca4 <rtems_rfs_file_io_end+0x34>       <== NOT EXECUTED
4001fd20:	92 12 60 d0 	or  %o1, 0xd0, %o1                             <== NOT EXECUTED
                       bool                   read)                   
{                                                                     
  bool atime;                                                         
  bool mtime;                                                         
  bool length;                                                        
  int  rc = 0;                                                        
4001fd24:	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)))           
4001fd28:	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;                                          
4001fd2c:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
4001fd30:	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;                                          
4001fd34:	b2 06 40 03 	add  %i1, %g3, %i1                             
                                                                      
  if (handle->bpos.boff >=                                            
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
4001fd38:	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 >=                                            
4001fd3c:	80 a6 40 02 	cmp  %i1, %g2                                  
4001fd40:	0a 80 00 07 	bcs  4001fd5c <rtems_rfs_file_io_end+0xec>     
4001fd44:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
      rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))           
  {                                                                   
    handle->bpos.bno++;                                               
4001fd48:	c6 07 60 10 	ld  [ %i5 + 0x10 ], %g3                        
    handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001fd4c:	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++;                                               
4001fd50:	86 00 e0 01 	inc  %g3                                       
    handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
4001fd54:	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++;                                               
4001fd58:	c6 27 60 10 	st  %g3, [ %i5 + 0x10 ]                        
  }                                                                   
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
4001fd5c:	80 a6 a0 00 	cmp  %i2, 0                                    
4001fd60:	32 80 00 11 	bne,a   4001fda4 <rtems_rfs_file_io_end+0x134> 
4001fd64:	f2 07 40 00 	ld  [ %i5 ], %i1                               
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
4001fd68:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
  }                                                                   
                                                                      
  length = false;                                                     
  mtime = false;                                                      
                                                                      
  if (!read &&                                                        
4001fd6c:	80 a0 a0 00 	cmp  %g2, 0                                    
4001fd70:	02 80 00 05 	be  4001fd84 <rtems_rfs_file_io_end+0x114>     
4001fd74:	c6 00 60 3c 	ld  [ %g1 + 0x3c ], %g3                        
      rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),      
4001fd78:	80 a0 e0 00 	cmp  %g3, 0                                    
4001fd7c:	22 80 00 25 	be,a   4001fe10 <rtems_rfs_file_io_end+0x1a0>  <== NEVER TAKEN
4001fd80:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        <== NOT EXECUTED
4001fd84:	80 a0 c0 02 	cmp  %g3, %g2                                  
4001fd88:	28 80 00 22 	bleu,a   4001fe10 <rtems_rfs_file_io_end+0x1a0>
4001fd8c:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        
4001fd90:	86 00 ff ff 	add  %g3, -1, %g3                              
4001fd94:	80 a0 80 03 	cmp  %g2, %g3                                  
4001fd98:	22 80 00 5f 	be,a   4001ff14 <rtems_rfs_file_io_end+0x2a4>  
4001fd9c:	c6 07 60 14 	ld  [ %i5 + 0x14 ], %g3                        
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001fda0:	f2 07 40 00 	ld  [ %i5 ], %i1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
4001fda4:	b8 10 20 00 	clr  %i4                                       
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001fda8:	b2 0e 60 01 	and  %i1, 1, %i1                               
4001fdac:	b2 1e 60 01 	xor  %i1, 1, %i1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
  length = rtems_rfs_file_update_length (handle) && length;           
4001fdb0:	b6 10 20 00 	clr  %i3                                       
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001fdb4:	90 10 20 20 	mov  0x20, %o0                                 
4001fdb8:	92 10 20 00 	clr  %o1                                       
4001fdbc:	7f ff d4 ba 	call  400150a4 <rtems_rfs_trace>               
4001fdc0:	b2 0e 60 ff 	and  %i1, 0xff, %i1                            
4001fdc4:	80 8a 20 ff 	btst  0xff, %o0                                
4001fdc8:	12 80 00 22 	bne  4001fe50 <rtems_rfs_file_io_end+0x1e0>    <== NEVER TAKEN
4001fdcc:	80 a0 00 19 	cmp  %g0, %i1                                  
4001fdd0:	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)                                                 
4001fdd4:	80 a7 20 00 	cmp  %i4, 0                                    
4001fdd8:	12 80 00 33 	bne  4001fea4 <rtems_rfs_file_io_end+0x234>    
4001fddc:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            
4001fde0:	80 a6 60 00 	cmp  %i1, 0                                    
4001fde4:	12 80 00 30 	bne  4001fea4 <rtems_rfs_file_io_end+0x234>    <== ALWAYS TAKEN
4001fde8:	80 a6 e0 00 	cmp  %i3, 0                                    
    if (read && atime)                                                
      handle->shared->atime = now;                                    
    if (!read && mtime)                                               
      handle->shared->mtime = now;                                    
  }                                                                   
  if (length)                                                         
4001fdec:	02 80 00 17 	be  4001fe48 <rtems_rfs_file_io_end+0x1d8>     
4001fdf0:	01 00 00 00 	nop                                            
  {                                                                   
    handle->shared->size.count =                                      
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
4001fdf4:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
    if (!read && mtime)                                               
      handle->shared->mtime = now;                                    
  }                                                                   
  if (length)                                                         
  {                                                                   
    handle->shared->size.count =                                      
4001fdf8:	c6 00 60 3c 	ld  [ %g1 + 0x3c ], %g3                        
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
    handle->shared->size.offset =                                     
4001fdfc:	c4 00 60 40 	ld  [ %g1 + 0x40 ], %g2                        
    if (!read && mtime)                                               
      handle->shared->mtime = now;                                    
  }                                                                   
  if (length)                                                         
  {                                                                   
    handle->shared->size.count =                                      
4001fe00:	c6 20 60 84 	st  %g3, [ %g1 + 0x84 ]                        
      rtems_rfs_block_map_count (rtems_rfs_file_map (handle));        
    handle->shared->size.offset =                                     
4001fe04:	c4 20 60 88 	st  %g2, [ %g1 + 0x88 ]                        
4001fe08:	81 c7 e0 08 	ret                                            
4001fe0c:	81 e8 00 00 	restore                                        
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001fe10:	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;                                          
4001fe14:	c6 20 60 40 	st  %g3, [ %g1 + 0x40 ]                        
  map->dirty = true;                                                  
4001fe18:	86 10 20 01 	mov  1, %g3                                    
4001fe1c:	c6 28 60 34 	stb  %g3, [ %g1 + 0x34 ]                       
4001fe20:	b2 08 a0 01 	and  %g2, 1, %i1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
4001fe24:	b9 30 a0 01 	srl  %g2, 1, %i4                               
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001fe28:	b2 1e 60 01 	xor  %i1, 1, %i1                               
  mtime  = rtems_rfs_file_update_mtime (handle) && mtime;             
4001fe2c:	b8 1f 20 01 	xor  %i4, 1, %i4                               
  length = rtems_rfs_file_update_length (handle) && length;           
4001fe30:	b6 10 20 01 	mov  1, %i3                                    
4001fe34:	80 88 a0 04 	btst  4, %g2                                   
4001fe38:	02 bf ff df 	be  4001fdb4 <rtems_rfs_file_io_end+0x144>     <== ALWAYS TAKEN
4001fe3c:	b8 0f 20 01 	and  %i4, 1, %i4                               
4001fe40:	10 bf ff dd 	b  4001fdb4 <rtems_rfs_file_io_end+0x144>      <== NOT EXECUTED
4001fe44:	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;                                                          
}                                                                     
4001fe48:	81 c7 e0 08 	ret                                            
4001fe4c:	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",
4001fe50:	b8 0f 20 ff 	and  %i4, 0xff, %i4                            <== NOT EXECUTED
4001fe54:	96 40 3f ff 	addx  %g0, -1, %o3                             <== NOT EXECUTED
4001fe58:	d2 07 60 10 	ld  [ %i5 + 0x10 ], %o1                        <== NOT EXECUTED
4001fe5c:	80 a0 00 1c 	cmp  %g0, %i4                                  <== NOT EXECUTED
4001fe60:	d4 07 60 14 	ld  [ %i5 + 0x14 ], %o2                        <== NOT EXECUTED
4001fe64:	98 40 3f ff 	addx  %g0, -1, %o4                             <== NOT EXECUTED
4001fe68:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            <== NOT EXECUTED
4001fe6c:	80 a0 00 1b 	cmp  %g0, %i3                                  <== NOT EXECUTED
4001fe70:	96 0a ff ec 	and  %o3, -20, %o3                             <== NOT EXECUTED
4001fe74:	9a 40 3f ff 	addx  %g0, -1, %o5                             <== NOT EXECUTED
4001fe78:	98 0b 3f e0 	and  %o4, -32, %o4                             <== NOT EXECUTED
4001fe7c:	9a 0b 7f e1 	and  %o5, -31, %o5                             <== NOT EXECUTED
4001fe80:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001fe84:	96 02 e0 41 	add  %o3, 0x41, %o3                            <== NOT EXECUTED
4001fe88:	90 12 22 20 	or  %o0, 0x220, %o0                            <== NOT EXECUTED
4001fe8c:	98 03 20 4d 	add  %o4, 0x4d, %o4                            <== NOT EXECUTED
4001fe90:	40 00 14 bb 	call  4002517c <printf>                        <== NOT EXECUTED
4001fe94:	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)                                                 
4001fe98:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4001fe9c:	02 bf ff d2 	be  4001fde4 <rtems_rfs_file_io_end+0x174>     <== NOT EXECUTED
4001fea0:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
  {                                                                   
    time_t now = time (NULL);                                         
4001fea4:	40 00 24 fa 	call  4002928c <time>                          
4001fea8:	90 10 20 00 	clr  %o0                                       
    if (read && atime)                                                
4001feac:	80 a6 60 00 	cmp  %i1, 0                                    
4001feb0:	02 80 00 06 	be  4001fec8 <rtems_rfs_file_io_end+0x258>     <== NEVER TAKEN
4001feb4:	80 a7 20 00 	cmp  %i4, 0                                    
4001feb8:	80 a6 a0 00 	cmp  %i2, 0                                    
4001febc:	32 80 00 0b 	bne,a   4001fee8 <rtems_rfs_file_io_end+0x278> 
4001fec0:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      handle->shared->atime = now;                                    
    if (!read && mtime)                                               
4001fec4:	80 a7 20 00 	cmp  %i4, 0                                    
4001fec8:	02 bf ff c9 	be  4001fdec <rtems_rfs_file_io_end+0x17c>     
4001fecc:	80 a6 e0 00 	cmp  %i3, 0                                    
4001fed0:	80 a6 a0 01 	cmp  %i2, 1                                    
4001fed4:	02 bf ff c6 	be  4001fdec <rtems_rfs_file_io_end+0x17c>     <== NEVER TAKEN
4001fed8:	80 a6 e0 00 	cmp  %i3, 0                                    
      handle->shared->mtime = now;                                    
4001fedc:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
4001fee0:	10 bf ff c3 	b  4001fdec <rtems_rfs_file_io_end+0x17c>      
4001fee4:	d0 20 60 90 	st  %o0, [ %g1 + 0x90 ]                        
                                                                      
  if (atime || mtime)                                                 
  {                                                                   
    time_t now = time (NULL);                                         
    if (read && atime)                                                
      handle->shared->atime = now;                                    
4001fee8:	10 bf ff f7 	b  4001fec4 <rtems_rfs_file_io_end+0x254>      
4001feec:	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), 
4001fef0:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4001fef4:	92 07 60 04 	add  %i5, 4, %o1                               
4001fef8:	7f ff f5 d0 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001fefc:	39 10 00 dd 	sethi  %hi(0x40037400), %i4                    
                                          rtems_rfs_file_buffer (handle));
    if (rc > 0)                                                       
4001ff00:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001ff04:	14 bf ff 7b 	bg  4001fcf0 <rtems_rfs_file_io_end+0x80>      <== NEVER TAKEN
4001ff08:	b8 17 20 d0 	or  %i4, 0xd0, %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)))           
4001ff0c:	10 bf ff 88 	b  4001fd2c <rtems_rfs_file_io_end+0xbc>       
4001ff10:	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),      
4001ff14:	c4 00 60 40 	ld  [ %g1 + 0x40 ], %g2                        
4001ff18:	80 a0 c0 02 	cmp  %g3, %g2                                  
4001ff1c:	28 bf ff a2 	bleu,a   4001fda4 <rtems_rfs_file_io_end+0x134>
4001ff20:	f2 07 40 00 	ld  [ %i5 ], %i1                               
                                         handle->bpos.boff);          
    length = true;                                                    
    mtime = true;                                                     
  }                                                                   
                                                                      
  atime  = rtems_rfs_file_update_atime (handle);                      
4001ff24:	10 bf ff bc 	b  4001fe14 <rtems_rfs_file_io_end+0x1a4>      
4001ff28:	c4 07 40 00 	ld  [ %i5 ], %g2                               
                                                                      

4001ff2c <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))
4001ff2c:	c2 02 20 0c 	ld  [ %o0 + 0xc ], %g1                         
4001ff30:	80 a0 60 00 	cmp  %g1, 0                                    
4001ff34:	02 80 00 07 	be  4001ff50 <rtems_rfs_file_io_release+0x24>  <== ALWAYS TAKEN
4001ff38:	92 02 20 04 	add  %o0, 4, %o1                               
    rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 
4001ff3c:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        <== NOT EXECUTED
4001ff40:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
4001ff44:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
4001ff48:	7f ff f5 bc 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001ff4c:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                          rtems_rfs_file_buffer (handle));
  return rc;                                                          
}                                                                     
4001ff50:	81 c3 e0 08 	retl                                           
4001ff54:	90 10 20 00 	clr  %o0                                       
                                                                      

4001fa2c <rtems_rfs_file_io_start>: int rtems_rfs_file_io_start (rtems_rfs_file_handle* handle, size_t* available, bool read) {
4001fa2c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  size_t size;                                                        
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001fa30:	90 10 20 20 	mov  0x20, %o0                                 
4001fa34:	92 10 20 00 	clr  %o1                                       
4001fa38:	7f ff d5 9b 	call  400150a4 <rtems_rfs_trace>               
4001fa3c:	ba 10 00 18 	mov  %i0, %i5                                  
4001fa40:	80 8a 20 ff 	btst  0xff, %o0                                
4001fa44:	22 80 00 0d 	be,a   4001fa78 <rtems_rfs_file_io_start+0x4c> <== ALWAYS TAKEN
4001fa48:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
    printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
4001fa4c:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4001fa50:	02 80 00 2f 	be  4001fb0c <rtems_rfs_file_io_start+0xe0>    <== NOT EXECUTED
4001fa54:	13 10 00 e3 	sethi  %hi(0x40038c00), %o1                    <== NOT EXECUTED
4001fa58:	13 10 00 dd 	sethi  %hi(0x40037400), %o1                    <== NOT EXECUTED
4001fa5c:	92 12 60 d0 	or  %o1, 0xd0, %o1	! 400374d0 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
4001fa60:	d4 07 60 10 	ld  [ %i5 + 0x10 ], %o2                        <== NOT EXECUTED
4001fa64:	d6 07 60 14 	ld  [ %i5 + 0x14 ], %o3                        <== NOT EXECUTED
4001fa68:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001fa6c:	40 00 15 c4 	call  4002517c <printf>                        <== NOT EXECUTED
4001fa70:	90 12 20 f8 	or  %o0, 0xf8, %o0	! 40038cf8 <CSWTCH.2+0xf08> <== NOT EXECUTED
            read ? "read" : "write",  handle->bpos.bno, handle->bpos.boff);
                                                                      
  if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))           
4001fa74:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
4001fa78:	80 a0 60 00 	cmp  %g1, 0                                    
4001fa7c:	22 80 00 2c 	be,a   4001fb2c <rtems_rfs_file_io_start+0x100>
4001fa80:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
                                          block, request_read);       
    if (rc > 0)                                                       
      return rc;                                                      
  }                                                                   
                                                                      
  if (read                                                            
4001fa84:	80 a6 a0 00 	cmp  %i2, 0                                    
4001fa88:	02 80 00 0d 	be  4001fabc <rtems_rfs_file_io_start+0x90>    
4001fa8c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))       
4001fa90:	c4 00 60 44 	ld  [ %g1 + 0x44 ], %g2                        
4001fa94:	80 a0 a0 00 	cmp  %g2, 0                                    
4001fa98:	12 80 00 1f 	bne  4001fb14 <rtems_rfs_file_io_start+0xe8>   
4001fa9c:	c6 00 60 3c 	ld  [ %g1 + 0x3c ], %g3                        
4001faa0:	80 a0 e0 00 	cmp  %g3, 0                                    
4001faa4:	12 80 00 1d 	bne  4001fb18 <rtems_rfs_file_io_start+0xec>   <== ALWAYS TAKEN
4001faa8:	86 00 ff ff 	add  %g3, -1, %g3                              
      && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001faac:	f8 00 60 40 	ld  [ %g1 + 0x40 ], %i4                        <== NOT EXECUTED
4001fab0:	80 a7 20 00 	cmp  %i4, 0                                    
4001fab4:	32 80 00 05 	bne,a   4001fac8 <rtems_rfs_file_io_start+0x9c>
4001fab8:	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));      
4001fabc:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
4001fac0:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
                                                                      
  *available = size - rtems_rfs_file_block_offset (handle);           
4001fac4:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001fac8:	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);           
4001facc:	82 27 00 01 	sub  %i4, %g1, %g1                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001fad0:	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);           
4001fad4:	c2 26 40 00 	st  %g1, [ %i1 ]                               
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001fad8:	7f ff d5 73 	call  400150a4 <rtems_rfs_trace>               
4001fadc:	b0 10 20 00 	clr  %i0                                       
4001fae0:	80 8a 20 ff 	btst  0xff, %o0                                
4001fae4:	32 80 00 04 	bne,a   4001faf4 <rtems_rfs_file_io_start+0xc8><== NEVER TAKEN
4001fae8:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
    printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",       
            *available, size);                                        
                                                                      
  return 0;                                                           
}                                                                     
4001faec:	81 c7 e0 08 	ret                                            
4001faf0:	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",       
4001faf4:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
4001faf8:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001fafc:	40 00 15 a0 	call  4002517c <printf>                        <== NOT EXECUTED
4001fb00:	90 12 21 80 	or  %o0, 0x180, %o0	! 40038d80 <CSWTCH.2+0xf90><== NOT EXECUTED
            *available, size);                                        
                                                                      
  return 0;                                                           
}                                                                     
4001fb04:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001fb08:	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",
4001fb0c:	10 bf ff d5 	b  4001fa60 <rtems_rfs_file_io_start+0x34>     <== NOT EXECUTED
4001fb10:	92 12 60 f0 	or  %o1, 0xf0, %o1                             <== NOT EXECUTED
    if (rc > 0)                                                       
      return rc;                                                      
  }                                                                   
                                                                      
  if (read                                                            
      && rtems_rfs_block_map_last (rtems_rfs_file_map (handle))       
4001fb14:	86 00 ff ff 	add  %g3, -1, %g3                              
4001fb18:	80 a0 80 03 	cmp  %g2, %g3                                  
4001fb1c:	32 bf ff e9 	bne,a   4001fac0 <rtems_rfs_file_io_start+0x94>
4001fb20:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
      && rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
4001fb24:	10 bf ff e3 	b  4001fab0 <rtems_rfs_file_io_start+0x84>     
4001fb28:	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),        
4001fb2c:	94 07 60 10 	add  %i5, 0x10, %o2                            
4001fb30:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4001fb34:	96 07 bf fc 	add  %fp, -4, %o3                              
4001fb38:	7f ff f4 0b 	call  4001cb64 <rtems_rfs_block_map_find>      
4001fb3c:	92 02 60 34 	add  %o1, 0x34, %o1                            
                                   rtems_rfs_file_map (handle),       
                                   rtems_rfs_file_bpos (handle),      
                                   &block);                           
    if (rc > 0)                                                       
4001fb40:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001fb44:	04 80 00 0a 	ble  4001fb6c <rtems_rfs_file_io_start+0x140>  
4001fb48:	80 a6 20 06 	cmp  %i0, 6                                    
    {                                                                 
      /*                                                              
       * Has the read reached the EOF ?                               
       */                                                             
      if (read && (rc == ENXIO))                                      
4001fb4c:	32 bf ff e8 	bne,a   4001faec <rtems_rfs_file_io_start+0xc0><== NEVER TAKEN
4001fb50:	90 10 20 20 	mov  0x20, %o0                                 <== NOT EXECUTED
4001fb54:	80 a6 a0 00 	cmp  %i2, 0                                    
4001fb58:	22 80 00 2d 	be,a   4001fc0c <rtems_rfs_file_io_start+0x1e0><== ALWAYS TAKEN
4001fb5c:	80 a6 20 06 	cmp  %i0, 6                                    
      {                                                               
        *available = 0;                                               
4001fb60:	c0 26 40 00 	clr  [ %i1 ]                                   <== NOT EXECUTED
        return 0;                                                     
4001fb64:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001fb68:	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 &&                                                    
4001fb6c:	80 a6 a0 00 	cmp  %i2, 0                                    
4001fb70:	12 80 00 0d 	bne  4001fba4 <rtems_rfs_file_io_start+0x178>  
4001fb74:	82 10 00 1a 	mov  %i2, %g1                                  
4001fb78:	c4 07 60 14 	ld  [ %i5 + 0x14 ], %g2                        
4001fb7c:	80 a0 a0 00 	cmp  %g2, 0                                    
4001fb80:	12 80 00 09 	bne  4001fba4 <rtems_rfs_file_io_start+0x178>  
4001fb84:	82 10 20 01 	mov  1, %g1                                    
          (rtems_rfs_file_block_offset (handle) ||                    
           (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001fb88:	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) ||                    
4001fb8c:	c6 06 40 00 	ld  [ %i1 ], %g3                               
           (*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
4001fb90:	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) ||                    
4001fb94:	c4 00 a0 08 	ld  [ %g2 + 8 ], %g2                           
4001fb98:	80 a0 c0 02 	cmp  %g3, %g2                                  
4001fb9c:	3a 80 00 02 	bcc,a   4001fba4 <rtems_rfs_file_io_start+0x178><== NEVER TAKEN
4001fba0:	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))                    
4001fba4:	90 10 20 20 	mov  0x20, %o0                                 
4001fba8:	92 10 20 00 	clr  %o1                                       
4001fbac:	7f ff d5 3e 	call  400150a4 <rtems_rfs_trace>               
4001fbb0:	b8 08 60 ff 	and  %g1, 0xff, %i4                            
4001fbb4:	80 8a 20 ff 	btst  0xff, %o0                                
4001fbb8:	22 80 00 0b 	be,a   4001fbe4 <rtems_rfs_file_io_start+0x1b8><== ALWAYS TAKEN
4001fbbc:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
      printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001fbc0:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
4001fbc4:	02 80 00 24 	be  4001fc54 <rtems_rfs_file_io_start+0x228>   <== NOT EXECUTED
4001fbc8:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          <== NOT EXECUTED
4001fbcc:	15 10 00 db 	sethi  %hi(0x40036c00), %o2                    <== NOT EXECUTED
4001fbd0:	94 12 a3 50 	or  %o2, 0x350, %o2	! 40036f50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
4001fbd4:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4001fbd8:	40 00 15 69 	call  4002517c <printf>                        <== NOT EXECUTED
4001fbdc:	90 12 21 48 	or  %o0, 0x148, %o0	! 40038d48 <CSWTCH.2+0xf58><== NOT EXECUTED
              block, request_read ? "yes" : "no");                    
                                                                      
    rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle), 
4001fbe0:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
4001fbe4:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
4001fbe8:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4001fbec:	92 07 60 04 	add  %i5, 4, %o1                               
4001fbf0:	7f ff f7 0c 	call  4001d820 <rtems_rfs_buffer_handle_request>
4001fbf4:	96 10 00 1c 	mov  %i4, %o3                                  
                                          rtems_rfs_file_buffer (handle),
                                          block, request_read);       
    if (rc > 0)                                                       
4001fbf8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001fbfc:	04 bf ff a3 	ble  4001fa88 <rtems_rfs_file_io_start+0x5c>   <== ALWAYS TAKEN
4001fc00:	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;                                                           
}                                                                     
4001fc04:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001fc08:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      {                                                               
        *available = 0;                                               
        return 0;                                                     
      }                                                               
                                                                      
      if (rc != ENXIO)                                                
4001fc0c:	12 bf ff b8 	bne  4001faec <rtems_rfs_file_io_start+0xc0>   <== NEVER TAKEN
4001fc10:	90 10 20 20 	mov  0x20, %o0                                 
        return rc;                                                    
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                  
4001fc14:	7f ff d5 24 	call  400150a4 <rtems_rfs_trace>               
4001fc18:	92 10 20 00 	clr  %o1                                       
4001fc1c:	80 8a 20 ff 	btst  0xff, %o0                                
4001fc20:	12 80 00 10 	bne  4001fc60 <rtems_rfs_file_io_start+0x234>  <== NEVER TAKEN
4001fc24:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    
        printf ("rtems-rfs: file-io: start: grow\n");                 
                                                                      
      rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),      
4001fc28:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
4001fc2c:	94 10 20 01 	mov  1, %o2                                    
4001fc30:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4001fc34:	96 07 bf fc 	add  %fp, -4, %o3                              
4001fc38:	7f ff f4 4f 	call  4001cd74 <rtems_rfs_block_map_grow>      
4001fc3c:	92 02 60 34 	add  %o1, 0x34, %o1                            
                                     rtems_rfs_file_map (handle),     
                                     1, &block);                      
      if (rc > 0)                                                     
4001fc40:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001fc44:	14 bf ff aa 	bg  4001faec <rtems_rfs_file_io_start+0xc0>    
4001fc48:	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))                    
4001fc4c:	10 bf ff d7 	b  4001fba8 <rtems_rfs_file_io_start+0x17c>    
4001fc50:	90 10 20 20 	mov  0x20, %o0                                 
      printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
4001fc54:	15 10 00 d5 	sethi  %hi(0x40035400), %o2                    <== NOT EXECUTED
4001fc58:	10 bf ff df 	b  4001fbd4 <rtems_rfs_file_io_start+0x1a8>    <== NOT EXECUTED
4001fc5c:	94 12 a0 60 	or  %o2, 0x60, %o2	! 40035460 <Callbacks.6428+0x218><== NOT EXECUTED
                                                                      
      if (rc != ENXIO)                                                
        return rc;                                                    
                                                                      
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                  
        printf ("rtems-rfs: file-io: start: grow\n");                 
4001fc60:	40 00 15 df 	call  400253dc <puts>                          <== NOT EXECUTED
4001fc64:	90 12 21 28 	or  %o0, 0x128, %o0                            <== NOT EXECUTED
                                                                      
      rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),      
4001fc68:	10 bf ff f1 	b  4001fc2c <rtems_rfs_file_io_start+0x200>    <== NOT EXECUTED
4001fc6c:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        <== NOT EXECUTED
                                                                      

4001f3e0 <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) {
4001f3e0:	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))                    
4001f3e4:	90 10 20 08 	mov  8, %o0                                    
4001f3e8:	92 10 20 00 	clr  %o1                                       
4001f3ec:	7f ff d7 2e 	call  400150a4 <rtems_rfs_trace>               
4001f3f0:	a0 10 00 18 	mov  %i0, %l0                                  
4001f3f4:	80 8a 20 ff 	btst  0xff, %o0                                
4001f3f8:	12 80 00 2b 	bne  4001f4a4 <rtems_rfs_file_open+0xc4>       <== NEVER TAKEN
4001f3fc:	92 10 00 19 	mov  %i1, %o1                                  
    printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);          
                                                                      
  *file = NULL;                                                       
4001f400:	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));                   
4001f404:	90 10 20 20 	mov  0x20, %o0                                 
4001f408:	7f ff a8 e5 	call  4000979c <malloc>                        
4001f40c:	b0 10 20 0c 	mov  0xc, %i0                                  
  if (!handle)                                                        
4001f410:	80 a2 20 00 	cmp  %o0, 0                                    
4001f414:	02 80 00 4f 	be  4001f550 <rtems_rfs_file_open+0x170>       <== NEVER TAKEN
4001f418:	b8 10 00 08 	mov  %o0, %i4                                  
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(                        
  Chain_Control *the_chain                                            
)                                                                     
{                                                                     
  return _Chain_Head( the_chain )->next;                              
4001f41c:	fa 04 20 74 	ld  [ %l0 + 0x74 ], %i5                        
    return ENOMEM;                                                    
                                                                      
  memset (handle, 0, sizeof (rtems_rfs_file_handle));                 
4001f420:	c0 22 00 00 	clr  [ %o0 ]                                   
4001f424:	c0 22 20 04 	clr  [ %o0 + 4 ]                               
4001f428:	c0 22 20 10 	clr  [ %o0 + 0x10 ]                            
4001f42c:	c0 22 20 14 	clr  [ %o0 + 0x14 ]                            
4001f430:	c0 22 20 18 	clr  [ %o0 + 0x18 ]                            
4001f434:	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;                                                  
4001f438:	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 ));            
4001f43c:	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))               
4001f440:	80 a7 40 02 	cmp  %i5, %g2                                  
4001f444:	12 80 00 06 	bne  4001f45c <rtems_rfs_file_open+0x7c>       
4001f448:	c0 22 20 0c 	clr  [ %o0 + 0xc ]                             
4001f44c:	30 80 00 1b 	b,a   4001f4b8 <rtems_rfs_file_open+0xd8>      
4001f450:	80 a7 40 02 	cmp  %i5, %g2                                  
4001f454:	02 80 00 19 	be  4001f4b8 <rtems_rfs_file_open+0xd8>        <== ALWAYS TAKEN
4001f458:	01 00 00 00 	nop                                            
  {                                                                   
    rtems_rfs_file_shared* shared;                                    
    shared = (rtems_rfs_file_shared*) node;                           
    if (shared->inode.ino == ino)                                     
4001f45c:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
4001f460:	80 a6 40 01 	cmp  %i1, %g1                                  
4001f464:	32 bf ff fb 	bne,a   4001f450 <rtems_rfs_file_open+0x70>    <== ALWAYS TAKEN
4001f468:	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++;                                             
4001f46c:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
4001f470:	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++;                                             
4001f474:	82 00 60 01 	inc  %g1                                       <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
4001f478:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001f47c:	7f ff d7 0a 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f480:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           <== NOT EXECUTED
4001f484:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f488:	12 80 00 34 	bne  4001f558 <rtems_rfs_file_open+0x178>      <== NOT EXECUTED
4001f48c:	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;                                             
4001f490:	f4 27 00 00 	st  %i2, [ %i4 ]                               <== NOT EXECUTED
  handle->shared = shared;                                            
4001f494:	fa 27 20 1c 	st  %i5, [ %i4 + 0x1c ]                        
                                                                      
  *file = handle;                                                     
4001f498:	f8 26 c0 00 	st  %i4, [ %i3 ]                               
                                                                      
  return 0;                                                           
4001f49c:	81 c7 e0 08 	ret                                            
4001f4a0:	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);          
4001f4a4:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001f4a8:	40 00 17 35 	call  4002517c <printf>                        <== NOT EXECUTED
4001f4ac:	90 12 23 38 	or  %o0, 0x338, %o0	! 40038b38 <CSWTCH.2+0xd48><== NOT EXECUTED
                                                                      
  *file = NULL;                                                       
4001f4b0:	10 bf ff d5 	b  4001f404 <rtems_rfs_file_open+0x24>         <== NOT EXECUTED
4001f4b4:	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));                 
4001f4b8:	7f ff a8 b9 	call  4000979c <malloc>                        
4001f4bc:	90 10 20 9c 	mov  0x9c, %o0                                 
    if (!shared)                                                      
4001f4c0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001f4c4:	02 80 00 46 	be  4001f5dc <rtems_rfs_file_open+0x1fc>       <== NEVER TAKEN
4001f4c8:	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));               
4001f4cc:	40 00 16 ae 	call  40024f84 <memset>                        
4001f4d0:	94 10 20 9c 	mov  0x9c, %o2                                 
                                                                      
    rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);        
4001f4d4:	a2 07 60 0c 	add  %i5, 0xc, %l1                             
4001f4d8:	90 10 00 10 	mov  %l0, %o0                                  
4001f4dc:	92 10 00 19 	mov  %i1, %o1                                  
4001f4e0:	94 10 00 11 	mov  %l1, %o2                                  
4001f4e4:	7f ff d0 49 	call  40013608 <rtems_rfs_inode_open>          
4001f4e8:	96 10 20 01 	mov  1, %o3                                    
    if (rc > 0)                                                       
4001f4ec:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001f4f0:	04 80 00 23 	ble  4001f57c <rtems_rfs_file_open+0x19c>      <== ALWAYS TAKEN
4001f4f4:	90 10 20 08 	mov  8, %o0                                    
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                
4001f4f8:	7f ff d6 eb 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f4fc:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001f500:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f504:	02 80 00 09 	be  4001f528 <rtems_rfs_file_open+0x148>       <== NOT EXECUTED
4001f508:	01 00 00 00 	nop                                            <== NOT EXECUTED
        printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",  
4001f50c:	40 00 1b 66 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001f510:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001f514:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001f518:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001f51c:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001f520:	40 00 17 17 	call  4002517c <printf>                        <== NOT EXECUTED
4001f524:	90 12 23 80 	or  %o0, 0x380, %o0	! 40038b80 <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);                                                  
4001f528:	7f ff a7 00 	call  40009128 <free>                          <== NOT EXECUTED
4001f52c:	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);                       
4001f530:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001f534:	7f ff f8 41 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f538:	92 07 20 04 	add  %i4, 4, %o1                               <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
4001f53c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001f540:	c0 2f 20 04 	clrb  [ %i4 + 4 ]                              <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001f544:	c0 27 20 08 	clr  [ %i4 + 8 ]                               <== NOT EXECUTED
4001f548:	7f ff a6 f8 	call  40009128 <free>                          <== NOT EXECUTED
4001f54c:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             <== NOT EXECUTED
      return rc;                                                      
4001f550:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001f554:	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); 
4001f558:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
  handle->flags  = oflag;                                             
  handle->shared = shared;                                            
                                                                      
  *file = handle;                                                     
                                                                      
  return 0;                                                           
4001f55c:	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); 
4001f560:	40 00 17 07 	call  4002517c <printf>                        <== NOT EXECUTED
4001f564:	90 12 23 58 	or  %o0, 0x358, %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;                                             
4001f568:	f4 27 00 00 	st  %i2, [ %i4 ]                               <== NOT EXECUTED
  handle->shared = shared;                                            
4001f56c:	fa 27 20 1c 	st  %i5, [ %i4 + 0x1c ]                        <== NOT EXECUTED
                                                                      
  *file = handle;                                                     
4001f570:	f8 26 c0 00 	st  %i4, [ %i3 ]                               <== NOT EXECUTED
                                                                      
  return 0;                                                           
4001f574:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001f578:	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); 
4001f57c:	90 10 00 10 	mov  %l0, %o0                                  
4001f580:	92 10 00 11 	mov  %l1, %o1                                  
4001f584:	7f ff f4 a3 	call  4001c810 <rtems_rfs_block_map_open>      
4001f588:	94 07 60 34 	add  %i5, 0x34, %o2                            
    if (rc > 0)                                                       
4001f58c:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001f590:	24 80 00 1e 	ble,a   4001f608 <rtems_rfs_file_open+0x228>   <== ALWAYS TAKEN
4001f594:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                
4001f598:	90 10 20 08 	mov  8, %o0                                    <== NOT EXECUTED
4001f59c:	7f ff d6 c2 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4001f5a0:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4001f5a4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4001f5a8:	22 80 00 0a 	be,a   4001f5d0 <rtems_rfs_file_open+0x1f0>    <== NOT EXECUTED
4001f5ac:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
        printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
4001f5b0:	40 00 1b 3d 	call  400262a4 <strerror>                      <== NOT EXECUTED
4001f5b4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001f5b8:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
4001f5bc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001f5c0:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001f5c4:	40 00 16 ee 	call  4002517c <printf>                        <== NOT EXECUTED
4001f5c8:	90 12 23 b8 	or  %o0, 0x3b8, %o0	! 40038bb8 <CSWTCH.2+0xdc8><== NOT EXECUTED
                rc, strerror (rc));                                   
      rtems_rfs_inode_close (fs, &shared->inode);                     
4001f5cc:	92 10 00 11 	mov  %l1, %o1                                  <== NOT EXECUTED
4001f5d0:	7f ff d0 86 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001f5d4:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
4001f5d8:	30 bf ff d4 	b,a   4001f528 <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);                       
4001f5dc:	92 07 20 04 	add  %i4, 4, %o1                               <== NOT EXECUTED
4001f5e0:	7f ff f8 16 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001f5e4:	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;                                                  
4001f5e8:	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);                                                  
4001f5ec:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001f5f0:	c0 2f 20 04 	clrb  [ %i4 + 4 ]                              <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001f5f4:	c0 27 20 08 	clr  [ %i4 + 8 ]                               <== NOT EXECUTED
4001f5f8:	7f ff a6 cc 	call  40009128 <free>                          <== NOT EXECUTED
4001f5fc:	c0 27 20 0c 	clr  [ %i4 + 0xc ]                             <== NOT EXECUTED
      return ENOMEM;                                                  
4001f600:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001f604:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      rtems_rfs_buffer_handle_close (fs, &handle->buffer);            
      free (handle);                                                  
      return rc;                                                      
    }                                                                 
                                                                      
    shared->references = 1;                                           
4001f608:	84 10 20 01 	mov  1, %g2                                    
4001f60c:	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);             
4001f610:	f0 08 60 0c 	ldub  [ %g1 + 0xc ], %i0                       
4001f614:	c8 08 60 0d 	ldub  [ %g1 + 0xd ], %g4                       
4001f618:	c6 08 60 0f 	ldub  [ %g1 + 0xf ], %g3                       
4001f61c:	c4 08 60 0e 	ldub  [ %g1 + 0xe ], %g2                       
4001f620:	b1 2e 20 18 	sll  %i0, 0x18, %i0                            
4001f624:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001f628:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001f62c:	88 16 00 04 	or  %i0, %g4, %g4                              
4001f630:	86 11 00 03 	or  %g4, %g3, %g3                              
4001f634:	84 10 c0 02 	or  %g3, %g2, %g2                              
    shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
4001f638:	c4 27 60 84 	st  %g2, [ %i5 + 0x84 ]                        
    shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
4001f63c:	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);            
4001f640:	c4 08 60 0a 	ldub  [ %g1 + 0xa ], %g2                       
4001f644:	90 04 20 74 	add  %l0, 0x74, %o0                            
4001f648:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001f64c:	84 10 c0 02 	or  %g3, %g2, %g2                              
4001f650:	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);                   
4001f654:	f0 08 60 10 	ldub  [ %g1 + 0x10 ], %i0                      
4001f658:	c8 08 60 11 	ldub  [ %g1 + 0x11 ], %g4                      
4001f65c:	c6 08 60 13 	ldub  [ %g1 + 0x13 ], %g3                      
4001f660:	c4 08 60 12 	ldub  [ %g1 + 0x12 ], %g2                      
4001f664:	b1 2e 20 18 	sll  %i0, 0x18, %i0                            
4001f668:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001f66c:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001f670:	88 16 00 04 	or  %i0, %g4, %g4                              
4001f674:	86 11 00 03 	or  %g4, %g3, %g3                              
4001f678:	84 10 c0 02 	or  %g3, %g2, %g2                              
    shared->atime = rtems_rfs_inode_get_atime (&shared->inode);       
4001f67c:	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);                   
4001f680:	f0 08 60 14 	ldub  [ %g1 + 0x14 ], %i0                      
4001f684:	c8 08 60 15 	ldub  [ %g1 + 0x15 ], %g4                      
4001f688:	c6 08 60 17 	ldub  [ %g1 + 0x17 ], %g3                      
4001f68c:	c4 08 60 16 	ldub  [ %g1 + 0x16 ], %g2                      
4001f690:	b1 2e 20 18 	sll  %i0, 0x18, %i0                            
4001f694:	89 29 20 10 	sll  %g4, 0x10, %g4                            
4001f698:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001f69c:	88 16 00 04 	or  %i0, %g4, %g4                              
4001f6a0:	86 11 00 03 	or  %g4, %g3, %g3                              
4001f6a4:	84 10 c0 02 	or  %g3, %g2, %g2                              
    shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);       
4001f6a8:	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);                   
4001f6ac:	c8 08 60 18 	ldub  [ %g1 + 0x18 ], %g4                      
4001f6b0:	c6 08 60 19 	ldub  [ %g1 + 0x19 ], %g3                      
4001f6b4:	c4 08 60 1b 	ldub  [ %g1 + 0x1b ], %g2                      
4001f6b8:	c2 08 60 1a 	ldub  [ %g1 + 0x1a ], %g1                      
4001f6bc:	89 29 20 18 	sll  %g4, 0x18, %g4                            
4001f6c0:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
4001f6c4:	83 28 60 08 	sll  %g1, 8, %g1                               
4001f6c8:	86 11 00 03 	or  %g4, %g3, %g3                              
4001f6cc:	84 10 c0 02 	or  %g3, %g2, %g2                              
4001f6d0:	82 10 80 01 	or  %g2, %g1, %g1                              
4001f6d4:	92 10 00 1d 	mov  %i5, %o1                                  
    shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);       
4001f6d8:	c2 27 60 94 	st  %g1, [ %i5 + 0x94 ]                        
4001f6dc:	7f ff bc d4 	call  4000ea2c <_Chain_Append>                 
4001f6e0:	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);               
4001f6e4:	92 10 00 11 	mov  %l1, %o1                                  
4001f6e8:	94 10 20 00 	clr  %o2                                       
4001f6ec:	7f ff cf fe 	call  400136e4 <rtems_rfs_inode_unload>        
4001f6f0:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))                  
4001f6f4:	90 10 20 08 	mov  8, %o0                                    
4001f6f8:	7f ff d6 6b 	call  400150a4 <rtems_rfs_trace>               
4001f6fc:	92 10 20 00 	clr  %o1                                       
4001f700:	80 8a 20 ff 	btst  0xff, %o0                                
4001f704:	22 bf ff 64 	be,a   4001f494 <rtems_rfs_file_open+0xb4>     <== ALWAYS TAKEN
4001f708:	f4 27 00 00 	st  %i2, [ %i4 ]                               
      printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
4001f70c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
4001f710:	11 10 00 e2 	sethi  %hi(0x40038800), %o0                    <== NOT EXECUTED
4001f714:	40 00 16 9a 	call  4002517c <printf>                        <== NOT EXECUTED
4001f718:	90 12 23 f0 	or  %o0, 0x3f0, %o0	! 40038bf0 <CSWTCH.2+0xe00><== NOT EXECUTED
  }                                                                   
                                                                      
  handle->flags  = oflag;                                             
4001f71c:	10 bf ff 5e 	b  4001f494 <rtems_rfs_file_open+0xb4>         <== NOT EXECUTED
4001f720:	f4 27 00 00 	st  %i2, [ %i4 ]                               <== NOT EXECUTED
                                                                      

4001ff58 <rtems_rfs_file_seek>: int rtems_rfs_file_seek (rtems_rfs_file_handle* handle, rtems_rfs_pos pos, rtems_rfs_pos* new_pos) {
4001ff58:	9d e3 bf 98 	save  %sp, -104, %sp                           
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4001ff5c:	90 10 20 20 	mov  0x20, %o0                                 
4001ff60:	92 10 20 00 	clr  %o1                                       
4001ff64:	7f ff d4 50 	call  400150a4 <rtems_rfs_trace>               
4001ff68:	ba 10 00 18 	mov  %i0, %i5                                  
4001ff6c:	80 8a 20 ff 	btst  0xff, %o0                                
4001ff70:	32 80 00 2b 	bne,a   4002001c <rtems_rfs_file_seek+0xc4>    <== NEVER TAKEN
4001ff74:	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),
4001ff78:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
4001ff7c:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4001ff80:	7f ff f2 0e 	call  4001c7b8 <rtems_rfs_block_get_size>      
4001ff84:	92 02 60 84 	add  %o1, 0x84, %o1                            
4001ff88:	80 a6 40 08 	cmp  %i1, %o0                                  
4001ff8c:	18 80 00 1b 	bgu  4001fff8 <rtems_rfs_file_seek+0xa0>       <== NEVER TAKEN
4001ff90:	01 00 00 00 	nop                                            
4001ff94:	02 80 00 17 	be  4001fff0 <rtems_rfs_file_seek+0x98>        <== ALWAYS TAKEN
4001ff98:	80 a6 80 09 	cmp  %i2, %o1                                  
                                            handle->shared))          
  {                                                                   
    rtems_rfs_file_set_bpos (handle, pos);                            
4001ff9c:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
4001ffa0:	b8 07 60 10 	add  %i5, 0x10, %i4                            
4001ffa4:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4001ffa8:	92 10 00 19 	mov  %i1, %o1                                  
4001ffac:	94 10 00 1a 	mov  %i2, %o2                                  
4001ffb0:	7f ff f1 d3 	call  4001c6fc <rtems_rfs_block_get_bpos>      
4001ffb4:	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))          
4001ffb8:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4001ffbc:	80 a0 60 00 	cmp  %g1, 0                                    
4001ffc0:	02 80 00 13 	be  4002000c <rtems_rfs_file_seek+0xb4>        
4001ffc4:	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),      
4001ffc8:	d2 07 60 1c 	ld  [ %i5 + 0x1c ], %o1                        
4001ffcc:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4001ffd0:	96 07 bf fc 	add  %fp, -4, %o3                              
4001ffd4:	7f ff f2 e4 	call  4001cb64 <rtems_rfs_block_map_find>      
4001ffd8:	92 02 60 34 	add  %o1, 0x34, %o1                            
                                     rtems_rfs_file_map (handle),     
                                     rtems_rfs_file_bpos (handle),    
                                     &block);                         
      if (rc > 0)                                                     
4001ffdc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001ffe0:	24 80 00 15 	ble,a   40020034 <rtems_rfs_file_seek+0xdc>    <== ALWAYS TAKEN
4001ffe4:	c4 07 60 08 	ld  [ %i5 + 8 ], %g2                           
      return rc;                                                      
  }                                                                   
                                                                      
  *new_pos = pos;                                                     
  return 0;                                                           
}                                                                     
4001ffe8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001ffec:	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),
4001fff0:	28 bf ff ec 	bleu,a   4001ffa0 <rtems_rfs_file_seek+0x48>   
4001fff4:	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);                      
4001fff8:	7f ff ff cd 	call  4001ff2c <rtems_rfs_file_io_release>     
4001fffc:	90 10 00 1d 	mov  %i5, %o0                                  
    if (rc > 0)                                                       
40020000:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40020004:	14 80 00 16 	bg  4002005c <rtems_rfs_file_seek+0x104>       <== NEVER TAKEN
40020008:	01 00 00 00 	nop                                            
      return rc;                                                      
  }                                                                   
                                                                      
  *new_pos = pos;                                                     
4002000c:	f2 26 c0 00 	st  %i1, [ %i3 ]                               
40020010:	f4 26 e0 04 	st  %i2, [ %i3 + 4 ]                           
  return 0;                                                           
}                                                                     
40020014:	81 c7 e0 08 	ret                                            
40020018:	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);          
4002001c:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
40020020:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40020024:	40 00 14 56 	call  4002517c <printf>                        <== NOT EXECUTED
40020028:	90 12 22 58 	or  %o0, 0x258, %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),
4002002c:	10 bf ff d4 	b  4001ff7c <rtems_rfs_file_seek+0x24>         <== NOT EXECUTED
40020030:	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)           
40020034:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40020038:	80 a0 80 01 	cmp  %g2, %g1                                  
4002003c:	02 bf ff f4 	be  4002000c <rtems_rfs_file_seek+0xb4>        <== ALWAYS TAKEN
40020040:	92 07 60 04 	add  %i5, 4, %o1                               
      {                                                               
        rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40020044:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        <== NOT EXECUTED
40020048:	7f ff f5 7c 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4002004c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
                                              rtems_rfs_file_buffer (handle));
        if (rc > 0)                                                   
40020050:	b0 92 20 00 	orcc  %o0, 0, %i0                              <== NOT EXECUTED
40020054:	24 bf ff ef 	ble,a   40020010 <rtems_rfs_file_seek+0xb8>    <== NOT EXECUTED
40020058:	f2 26 c0 00 	st  %i1, [ %i3 ]                               <== NOT EXECUTED
      return rc;                                                      
  }                                                                   
                                                                      
  *new_pos = pos;                                                     
  return 0;                                                           
}                                                                     
4002005c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020060:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40020064 <rtems_rfs_file_set_size>: int rtems_rfs_file_set_size (rtems_rfs_file_handle* handle, rtems_rfs_pos new_size) {
40020064:	9d e3 bf 90 	save  %sp, -112, %sp                           
  rtems_rfs_block_map* map  = rtems_rfs_file_map (handle);            
40020068:	f6 06 20 1c 	ld  [ %i0 + 0x1c ], %i3                        
  rtems_rfs_pos        size;                                          
  int                  rc;                                            
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))                      
4002006c:	90 10 20 20 	mov  0x20, %o0                                 
40020070:	92 10 20 00 	clr  %o1                                       
40020074:	7f ff d4 0c 	call  400150a4 <rtems_rfs_trace>               
40020078:	b8 10 00 19 	mov  %i1, %i4                                  
}                                                                     
                                                                      
int                                                                   
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,               
                         rtems_rfs_pos          new_size)             
{                                                                     
4002007c:	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))                      
40020080:	80 8a 20 ff 	btst  0xff, %o0                                
40020084:	12 80 00 92 	bne  400202cc <rtems_rfs_file_set_size+0x268>  <== NEVER TAKEN
40020088:	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);                                
4002008c:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
40020090:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
40020094:	7f ff f1 c9 	call  4001c7b8 <rtems_rfs_block_get_size>      
40020098:	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)                                               
4002009c:	80 a7 00 08 	cmp  %i4, %o0                                  
400200a0:	02 80 00 98 	be  40020300 <rtems_rfs_file_set_size+0x29c>   <== ALWAYS TAKEN
400200a4:	80 a7 40 09 	cmp  %i5, %o1                                  
  {                                                                   
    /*                                                                
     * Short cut for the common truncate on open call.                
     */                                                               
    if (new_size == 0)                                                
400200a8:	80 97 00 1d 	orcc  %i4, %i5, %g0                            <== NOT EXECUTED
400200ac:	22 80 00 9a 	be,a   40020314 <rtems_rfs_file_set_size+0x2b0><== NOT EXECUTED
400200b0:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        <== NOT EXECUTED
      if (rc > 0)                                                     
        return rc;                                                    
    }                                                                 
    else                                                              
    {                                                                 
      if (size < new_size)                                            
400200b4:	80 a7 00 08 	cmp  %i4, %o0                                  <== NOT EXECUTED
400200b8:	08 80 00 57 	bleu  40020214 <rtems_rfs_file_set_size+0x1b0> <== ALWAYS TAKEN
400200bc:	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));
400200c0:	e8 06 20 1c 	ld  [ %i0 + 0x1c ], %l4                        <== NOT EXECUTED
         */                                                           
        rtems_rfs_pos count;                                          
        uint32_t      length;                                         
        bool          read_block;                                     
                                                                      
        count = new_size - size;                                      
400200c4:	ba a7 40 09 	subcc  %i5, %o1, %i5                           
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
400200c8:	c2 05 20 98 	ld  [ %l4 + 0x98 ], %g1                        
         */                                                           
        rtems_rfs_pos count;                                          
        uint32_t      length;                                         
        bool          read_block;                                     
                                                                      
        count = new_size - size;                                      
400200cc:	b8 67 00 08 	subx  %i4, %o0, %i4                            
        length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
400200d0:	a6 10 00 14 	mov  %l4, %l3                                  
400200d4:	f4 00 60 08 	ld  [ %g1 + 8 ], %i2                           
        read_block = false;                                           
                                                                      
        while (count)                                                 
400200d8:	a4 10 20 00 	clr  %l2                                       
400200dc:	a2 10 20 01 	mov  1, %l1                                    
400200e0:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
400200e4:	12 80 00 2a 	bne  4002018c <rtems_rfs_file_set_size+0x128>  <== ALWAYS TAKEN
400200e8:	a0 06 20 04 	add  %i0, 4, %l0                               
400200ec:	10 80 00 92 	b  40020334 <rtems_rfs_file_set_size+0x2d0>    <== NOT EXECUTED
400200f0:	f4 06 e0 3c 	ld  [ %i3 + 0x3c ], %i2                        <== NOT EXECUTED
                                           map, 1, &block);           
            if (rc > 0)                                               
              return rc;                                              
          }                                                           
                                                                      
          if (count < (length - bpos.boff))                           
400200f4:	80 a0 80 1d 	cmp  %g2, %i5                                  
400200f8:	28 80 00 45 	bleu,a   4002020c <rtems_rfs_file_set_size+0x1a8>
400200fc:	c0 26 e0 40 	clr  [ %i3 + 0x40 ]                            
          {                                                           
            length = count + bpos.boff;                               
40020100:	b4 00 40 1d 	add  %g1, %i5, %i2                             
40020104:	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;                                          
40020108:	f4 26 e0 40 	st  %i2, [ %i3 + 0x40 ]                        
            read_block = true;                                        
4002010c:	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),
40020110:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
40020114:	d4 07 bf f0 	ld  [ %fp + -16 ], %o2                         
40020118:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
4002011c:	92 10 00 10 	mov  %l0, %o1                                  
40020120:	7f ff f5 c0 	call  4001d820 <rtems_rfs_buffer_handle_request>
40020124:	96 0c a0 01 	and  %l2, 1, %o3                               
                                                rtems_rfs_file_buffer (handle),
                                                block, read_block);   
          if (rc > 0)                                                 
40020128:	82 92 20 00 	orcc  %o0, 0, %g1                              
4002012c:	14 80 00 66 	bg  400202c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
40020130:	92 10 20 00 	clr  %o1                                       
            return rc;                                                
                                                                      
          dst = rtems_rfs_buffer_data (&handle->buffer);              
40020134:	c4 06 20 0c 	ld  [ %i0 + 0xc ], %g2                         
          memset (dst + bpos.boff, 0, length - bpos.boff);            
40020138:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4002013c:	d0 00 a0 1c 	ld  [ %g2 + 0x1c ], %o0                        
40020140:	94 26 80 01 	sub  %i2, %g1, %o2                             
40020144:	40 00 13 90 	call  40024f84 <memset>                        
40020148:	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),
4002014c:	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));
40020150:	e2 2e 20 04 	stb  %l1, [ %i0 + 4 ]                          
                                                                      
          rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
40020154:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
40020158:	7f ff f5 38 	call  4001d638 <rtems_rfs_buffer_handle_release>
4002015c:	92 10 00 10 	mov  %l0, %o1                                  
                                                rtems_rfs_file_buffer (handle));
          if (rc > 0)                                                 
40020160:	82 92 20 00 	orcc  %o0, 0, %g1                              
40020164:	14 80 00 58 	bg  400202c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
40020168:	01 00 00 00 	nop                                            
            return rc;                                                
                                                                      
          count -= length - bpos.boff;                                
4002016c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40020170:	82 26 80 01 	sub  %i2, %g1, %g1                             
40020174:	ba a7 40 01 	subcc  %i5, %g1, %i5                           
40020178:	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)                                                 
4002017c:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
40020180:	22 80 00 6c 	be,a   40020330 <rtems_rfs_file_set_size+0x2cc>
40020184:	e8 06 20 1c 	ld  [ %i0 + 0x1c ], %l4                        
40020188:	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);
4002018c:	c2 06 e0 40 	ld  [ %i3 + 0x40 ], %g1                        
40020190:	c4 06 e0 3c 	ld  [ %i3 + 0x3c ], %g2                        
40020194:	c2 27 bf f8 	st  %g1, [ %fp + -8 ]                          
40020198:	c4 27 bf f4 	st  %g2, [ %fp + -12 ]                         
4002019c:	80 a0 60 00 	cmp  %g1, 0                                    
400201a0:	02 80 00 04 	be  400201b0 <rtems_rfs_file_set_size+0x14c>   
400201a4:	c0 27 bf fc 	clr  [ %fp + -4 ]                              
400201a8:	84 00 bf ff 	add  %g2, -1, %g2                              
400201ac:	c4 27 bf f4 	st  %g2, [ %fp + -12 ]                         
          rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),  
400201b0:	d0 04 e0 98 	ld  [ %l3 + 0x98 ], %o0                        
400201b4:	92 10 00 19 	mov  %i1, %o1                                  
400201b8:	94 07 bf f4 	add  %fp, -12, %o2                             
400201bc:	7f ff f2 6a 	call  4001cb64 <rtems_rfs_block_map_find>      
400201c0:	96 07 bf f0 	add  %fp, -16, %o3                             
                                         map, &bpos, &block);         
          if (rc > 0)                                                 
400201c4:	82 92 20 00 	orcc  %o0, 0, %g1                              
400201c8:	04 80 00 0c 	ble  400201f8 <rtems_rfs_file_set_size+0x194>  
400201cc:	80 a0 60 06 	cmp  %g1, 6                                    
          {                                                           
            /*                                                        
             * Have we reached the EOF ?                              
             */                                                       
            if (rc != ENXIO)                                          
400201d0:	12 80 00 3d 	bne  400202c4 <rtems_rfs_file_set_size+0x260>  <== NEVER TAKEN
400201d4:	92 10 00 19 	mov  %i1, %o1                                  
              return rc;                                              
                                                                      
            rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
400201d8:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
400201dc:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
400201e0:	94 10 20 01 	mov  1, %o2                                    
400201e4:	7f ff f2 e4 	call  4001cd74 <rtems_rfs_block_map_grow>      
400201e8:	96 07 bf f0 	add  %fp, -16, %o3                             
                                           map, 1, &block);           
            if (rc > 0)                                               
400201ec:	82 92 20 00 	orcc  %o0, 0, %g1                              
400201f0:	14 80 00 35 	bg  400202c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
400201f4:	01 00 00 00 	nop                                            
              return rc;                                              
          }                                                           
                                                                      
          if (count < (length - bpos.boff))                           
400201f8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
400201fc:	80 a7 20 00 	cmp  %i4, 0                                    
40020200:	02 bf ff bd 	be  400200f4 <rtems_rfs_file_set_size+0x90>    <== ALWAYS TAKEN
40020204:	84 26 80 01 	sub  %i2, %g1, %g2                             
40020208:	c0 26 e0 40 	clr  [ %i3 + 0x40 ]                            <== NOT EXECUTED
  map->dirty = true;                                                  
4002020c:	10 bf ff c1 	b  40020110 <rtems_rfs_file_set_size+0xac>     
40020210:	e2 2e e0 34 	stb  %l1, [ %i3 + 0x34 ]                       
      if (rc > 0)                                                     
        return rc;                                                    
    }                                                                 
    else                                                              
    {                                                                 
      if (size < new_size)                                            
40020214:	02 80 00 54 	be  40020364 <rtems_rfs_file_set_size+0x300>   <== ALWAYS TAKEN
40020218:	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);
4002021c:	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) -                           
40020220:	f4 06 e0 3c 	ld  [ %i3 + 0x3c ], %i2                        
          (((new_size - 1) /                                          
            rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
40020224:	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) /                                          
40020228:	92 87 7f ff 	addcc  %i5, -1, %o1                            
4002022c:	f2 04 20 08 	ld  [ %l0 + 8 ], %i1                           
40020230:	90 47 3f ff 	addx  %i4, -1, %o0                             
40020234:	96 10 00 19 	mov  %i1, %o3                                  
40020238:	40 00 48 24 	call  400322c8 <__udivdi3>                     
4002023c:	94 10 20 00 	clr  %o2                                       
         * Shrink                                                     
         */                                                           
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
40020240:	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));
40020244:	96 10 00 19 	mov  %i1, %o3                                  
40020248:	94 10 20 00 	clr  %o2                                       
         * Shrink                                                     
         */                                                           
        rtems_rfs_block_no blocks;                                    
        uint32_t           offset;                                    
                                                                      
        blocks =                                                      
4002024c:	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));
40020250:	90 10 00 1c 	mov  %i4, %o0                                  
40020254:	40 00 48 f1 	call  40032618 <__umoddi3>                     
40020258:	92 10 00 1d 	mov  %i5, %o1                                  
                                                                      
        if (blocks)                                                   
4002025c:	80 a6 60 00 	cmp  %i1, 0                                    
40020260:	12 80 00 4e 	bne  40020398 <rtems_rfs_file_set_size+0x334>  
40020264:	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),
40020268:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
4002026c:	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;                                          
40020270:	fa 26 e0 40 	st  %i5, [ %i3 + 0x40 ]                        
40020274:	80 a0 60 00 	cmp  %g1, 0                                    
40020278:	02 80 00 3f 	be  40020374 <rtems_rfs_file_set_size+0x310>   
4002027c:	c4 2e e0 34 	stb  %g2, [ %i3 + 0x34 ]                       
40020280:	80 a6 a0 00 	cmp  %i2, 0                                    
40020284:	12 80 00 3d 	bne  40020378 <rtems_rfs_file_set_size+0x314>  <== ALWAYS TAKEN
40020288:	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),
4002028c:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        <== NOT EXECUTED
40020290:	fa 26 20 14 	st  %i5, [ %i0 + 0x14 ]                        
40020294:	80 a7 60 00 	cmp  %i5, 0                                    
40020298:	02 80 00 3e 	be  40020390 <rtems_rfs_file_set_size+0x32c>   <== NEVER TAKEN
4002029c:	c0 26 20 18 	clr  [ %i0 + 0x18 ]                            
400202a0:	82 06 bf ff 	add  %i2, -1, %g1                              
400202a4:	a8 10 00 13 	mov  %l3, %l4                                  
400202a8:	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))                         
400202ac:	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);    
400202b0:	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))                         
400202b4:	80 88 60 02 	btst  2, %g1                                   
400202b8:	02 80 00 25 	be  4002034c <rtems_rfs_file_set_size+0x2e8>   <== ALWAYS TAKEN
400202bc:	fa 25 20 88 	st  %i5, [ %l4 + 0x88 ]                        
      handle->shared->mtime = time (NULL);                            
  }                                                                   
                                                                      
  return 0;                                                           
400202c0:	82 10 20 00 	clr  %g1                                       
}                                                                     
400202c4:	81 c7 e0 08 	ret                                            
400202c8:	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);
400202cc:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
400202d0:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
400202d4:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
400202d8:	40 00 13 a9 	call  4002517c <printf>                        <== NOT EXECUTED
400202dc:	90 12 22 78 	or  %o0, 0x278, %o0	! 40038e78 <CSWTCH.2+0x1088><== NOT EXECUTED
                                                                      
  size = rtems_rfs_file_size (handle);                                
400202e0:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        <== NOT EXECUTED
400202e4:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        <== NOT EXECUTED
400202e8:	7f ff f1 34 	call  4001c7b8 <rtems_rfs_block_get_size>      <== NOT EXECUTED
400202ec:	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)                                               
400202f0:	80 a7 00 08 	cmp  %i4, %o0                                  <== NOT EXECUTED
400202f4:	12 bf ff 6e 	bne  400200ac <rtems_rfs_file_set_size+0x48>   <== NOT EXECUTED
400202f8:	80 97 00 1d 	orcc  %i4, %i5, %g0                            <== NOT EXECUTED
400202fc:	80 a7 40 09 	cmp  %i5, %o1                                  <== NOT EXECUTED
40020300:	02 bf ff f0 	be  400202c0 <rtems_rfs_file_set_size+0x25c>   
40020304:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
  {                                                                   
    /*                                                                
     * Short cut for the common truncate on open call.                
     */                                                               
    if (new_size == 0)                                                
40020308:	12 bf ff 6c 	bne  400200b8 <rtems_rfs_file_set_size+0x54>   
4002030c:	80 a7 00 08 	cmp  %i4, %o0                                  
    {                                                                 
      rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
40020310:	c2 06 20 1c 	ld  [ %i0 + 0x1c ], %g1                        
40020314:	92 10 00 19 	mov  %i1, %o1                                  
40020318:	7f ff f4 55 	call  4001d46c <rtems_rfs_block_map_free_all>  
4002031c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
      if (rc > 0)                                                     
40020320:	82 92 20 00 	orcc  %o0, 0, %g1                              
40020324:	14 bf ff e8 	bg  400202c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
40020328:	01 00 00 00 	nop                                            
4002032c:	e8 06 20 1c 	ld  [ %i0 + 0x1c ], %l4                        
40020330:	f4 06 e0 3c 	ld  [ %i3 + 0x3c ], %i2                        
40020334:	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))                         
40020338:	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);    
4002033c:	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))                         
40020340:	80 88 60 02 	btst  2, %g1                                   
40020344:	12 bf ff df 	bne  400202c0 <rtems_rfs_file_set_size+0x25c>  <== NEVER TAKEN
40020348:	fa 25 20 88 	st  %i5, [ %l4 + 0x88 ]                        
      handle->shared->mtime = time (NULL);                            
4002034c:	40 00 23 d0 	call  4002928c <time>                          
40020350:	90 10 20 00 	clr  %o0                                       
  }                                                                   
                                                                      
  return 0;                                                           
40020354:	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);                            
40020358:	d0 25 20 90 	st  %o0, [ %l4 + 0x90 ]                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4002035c:	81 c7 e0 08 	ret                                            
40020360:	91 e8 00 01 	restore  %g0, %g1, %o0                         
      if (rc > 0)                                                     
        return rc;                                                    
    }                                                                 
    else                                                              
    {                                                                 
      if (size < new_size)                                            
40020364:	28 bf ff af 	bleu,a   40020220 <rtems_rfs_file_set_size+0x1bc>
40020368:	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));
4002036c:	10 bf ff 56 	b  400200c4 <rtems_rfs_file_set_size+0x60>     
40020370:	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),
40020374:	80 a0 40 1a 	cmp  %g1, %i2                                  
40020378:	3a bf ff c6 	bcc,a   40020290 <rtems_rfs_file_set_size+0x22c><== NEVER TAKEN
4002037c:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        <== NOT EXECUTED
40020380:	84 06 bf ff 	add  %i2, -1, %g2                              
40020384:	80 a0 40 02 	cmp  %g1, %g2                                  
40020388:	22 80 00 0e 	be,a   400203c0 <rtems_rfs_file_set_size+0x35c><== ALWAYS TAKEN
4002038c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
40020390:	10 bf ff c7 	b  400202ac <rtems_rfs_file_set_size+0x248>    <== NOT EXECUTED
40020394:	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),
40020398:	90 10 00 10 	mov  %l0, %o0                                  
4002039c:	92 04 e0 34 	add  %l3, 0x34, %o1                            
400203a0:	7f ff f3 6b 	call  4001d14c <rtems_rfs_block_map_shrink>    
400203a4:	94 10 00 19 	mov  %i1, %o2                                  
                                           rtems_rfs_file_map (handle),
                                           blocks);                   
          if (rc > 0)                                                 
400203a8:	82 92 20 00 	orcc  %o0, 0, %g1                              
400203ac:	14 bf ff c6 	bg  400202c4 <rtems_rfs_file_set_size+0x260>   <== NEVER TAKEN
400203b0:	01 00 00 00 	nop                                            
400203b4:	f4 06 e0 3c 	ld  [ %i3 + 0x3c ], %i2                        
400203b8:	10 bf ff ac 	b  40020268 <rtems_rfs_file_set_size+0x204>    
400203bc:	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),
400203c0:	80 a7 40 01 	cmp  %i5, %g1                                  
400203c4:	2a bf ff b3 	bcs,a   40020290 <rtems_rfs_file_set_size+0x22c>
400203c8:	f4 26 20 10 	st  %i2, [ %i0 + 0x10 ]                        
400203cc:	10 bf ff b8 	b  400202ac <rtems_rfs_file_set_size+0x248>    
400203d0:	a8 10 00 13 	mov  %l3, %l4                                  
                                                                      

40011e78 <rtems_rfs_format>: return rc; } int rtems_rfs_format (const char* name, const rtems_rfs_format_config* config) {
40011e78:	9d e3 be c8 	save  %sp, -312, %sp                           
  rtems_rfs_file_system fs;                                           
  int                   group;                                        
  int                   rc;                                           
                                                                      
  if (config->verbose)                                                
40011e7c:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      
40011e80:	80 a0 60 00 	cmp  %g1, 0                                    
40011e84:	32 80 00 88 	bne,a   400120a4 <rtems_rfs_format+0x22c>      <== NEVER TAKEN
40011e88:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
    printf ("rtems-rfs: format: %s\n", name);                         
                                                                      
  memset (&fs, 0, sizeof (rtems_rfs_file_system));                    
40011e8c:	92 10 20 00 	clr  %o1                                       
40011e90:	94 10 20 84 	mov  0x84, %o2                                 
40011e94:	40 00 4c 3c 	call  40024f84 <memset>                        
40011e98:	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;                                                  
40011e9c:	82 07 bf c4 	add  %fp, -60, %g1                             
40011ea0:	c2 27 bf c0 	st  %g1, [ %fp + -64 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
40011ea4:	82 07 bf c0 	add  %fp, -64, %g1                             
40011ea8:	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;                                                  
40011eac:	82 07 bf d4 	add  %fp, -44, %g1                             
40011eb0:	c2 27 bf d0 	st  %g1, [ %fp + -48 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
40011eb4:	82 07 bf d0 	add  %fp, -48, %g1                             
40011eb8:	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;                                                  
40011ebc:	82 07 bf e4 	add  %fp, -28, %g1                             
40011ec0:	c2 27 bf e0 	st  %g1, [ %fp + -32 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
40011ec4:	82 07 bf e0 	add  %fp, -32, %g1                             
40011ec8:	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;                                                  
40011ecc:	82 07 bf f4 	add  %fp, -12, %g1                             
40011ed0:	c2 27 bf f0 	st  %g1, [ %fp + -16 ]                         
  head->previous = NULL;                                              
  tail->previous = head;                                              
40011ed4:	82 07 bf f0 	add  %fp, -16, %g1                             
40011ed8:	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;                
40011edc:	82 10 20 05 	mov  5, %g1                                    
40011ee0:	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;                             
40011ee4:	82 10 20 02 	mov  2, %g1                                    
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, &fs);                             
40011ee8:	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;                             
40011eec:	c2 27 bf 7c 	st  %g1, [ %fp + -132 ]                        
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, &fs);                             
40011ef0:	40 00 2f 04 	call  4001db00 <rtems_rfs_buffer_open>         
40011ef4:	92 07 bf 7c 	add  %fp, -132, %o1                            
  if (rc > 0)                                                         
40011ef8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40011efc:	14 80 02 bd 	bg  400129f0 <rtems_rfs_format+0xb78>          <== NEVER TAKEN
40011f00:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        
  }                                                                   
                                                                      
  /*                                                                  
   * Check the media.                                                 
   */                                                                 
  if (rtems_rfs_fs_media_block_size (&fs) == 0)                       
40011f04:	f8 00 60 20 	ld  [ %g1 + 0x20 ], %i4                        
40011f08:	80 a7 20 00 	cmp  %i4, 0                                    
40011f0c:	02 80 02 c2 	be  40012a14 <rtems_rfs_format+0xb9c>          <== NEVER TAKEN
40011f10:	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;                                
40011f14:	fa 06 40 00 	ld  [ %i1 ], %i5                               
  if (!fs->block_size)                                                
40011f18:	80 a7 60 00 	cmp  %i5, 0                                    
40011f1c:	02 80 00 d1 	be  40012260 <rtems_rfs_format+0x3e8>          
40011f20:	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)     
40011f24:	90 10 00 1d 	mov  %i5, %o0                                  
40011f28:	40 00 7e 2b 	call  400317d4 <.urem>                         
40011f2c:	92 10 00 1c 	mov  %i4, %o1                                  
40011f30:	80 a2 20 00 	cmp  %o0, 0                                    
40011f34:	32 80 00 ef 	bne,a   400122f0 <rtems_rfs_format+0x478>      <== NEVER TAKEN
40011f38:	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;                            
40011f3c:	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);  
40011f40:	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)                                              
40011f44:	80 a0 60 00 	cmp  %g1, 0                                    
40011f48:	12 80 00 50 	bne  40012088 <rtems_rfs_format+0x210>         <== NEVER TAKEN
40011f4c:	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);  
40011f50:	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;         
40011f54:	40 00 39 3b 	call  40020440 <rtems_rfs_fs_media_size>       
40011f58:	90 07 bf 7c 	add  %fp, -132, %o0                            
40011f5c:	fa 07 bf 84 	ld  [ %fp + -124 ], %i5                        
40011f60:	94 10 20 00 	clr  %o2                                       
40011f64:	40 00 80 d9 	call  400322c8 <__udivdi3>                     
40011f68:	96 10 00 1d 	mov  %i5, %o3                                  
40011f6c:	d2 27 bf 80 	st  %o1, [ %fp + -128 ]                        
40011f70:	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));  
40011f74:	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)                                                  
40011f78:	80 a2 60 00 	cmp  %o1, 0                                    
40011f7c:	02 80 00 06 	be  40011f94 <rtems_rfs_format+0x11c>          <== NEVER TAKEN
40011f80:	a0 10 20 01 	mov  1, %l0                                    
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
40011f84:	90 02 7f ff 	add  %o1, -1, %o0                              
40011f88:	7f ff c1 c6 	call  400026a0 <.udiv>                         
40011f8c:	92 10 00 1a 	mov  %i2, %o1                                  
40011f90:	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;                            
40011f94:	f6 06 60 08 	ld  [ %i1 + 8 ], %i3                           
  if (!fs->group_inodes)                                              
40011f98:	80 a6 e0 00 	cmp  %i3, 0                                    
40011f9c:	02 80 01 38 	be  4001247c <rtems_rfs_format+0x604>          <== ALWAYS TAKEN
40011fa0:	e0 27 bf a0 	st  %l0, [ %fp + -96 ]                         
40011fa4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40011fa8:	7f ff c1 be 	call  400026a0 <.udiv>                         <== NOT EXECUTED
40011fac:	92 10 20 38 	mov  0x38, %o1                                 <== NOT EXECUTED
40011fb0:	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;
40011fb4:	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;                              
40011fb8:	90 06 ff ff 	add  %i3, -1, %o0                              <== NOT EXECUTED
40011fbc:	7f ff c1 b9 	call  400026a0 <.udiv>                         
40011fc0:	92 10 00 1c 	mov  %i4, %o1                                  
40011fc4:	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;
40011fc8:	7f ff c1 7c 	call  400025b8 <.umul>                         
40011fcc:	92 10 00 1c 	mov  %i4, %o1                                  
                                                                      
  if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
40011fd0:	80 a6 80 08 	cmp  %i2, %o0                                  
40011fd4:	0a 80 01 25 	bcs  40012468 <rtems_rfs_format+0x5f0>         <== NEVER TAKEN
40011fd8:	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)                                           
40011fdc:	80 a0 60 00 	cmp  %g1, 0                                    
40011fe0:	12 80 01 25 	bne  40012474 <rtems_rfs_format+0x5fc>         <== NEVER TAKEN
40011fe4:	d0 27 bf a8 	st  %o0, [ %fp + -88 ]                         
  {                                                                   
    fs->max_name_length = 512;                                        
40011fe8:	82 10 22 00 	mov  0x200, %g1                                
40011fec:	c2 27 bf 98 	st  %g1, [ %fp + -104 ]                        
   * Check the configuration data.                                    
   */                                                                 
  if (!rtems_rfs_check_config (&fs, config))                          
    return -1;                                                        
                                                                      
  if (config->verbose)                                                
40011ff0:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      
40011ff4:	80 a0 60 00 	cmp  %g1, 0                                    
40011ff8:	12 80 00 c5 	bne  4001230c <rtems_rfs_format+0x494>         <== NEVER TAKEN
40011ffc:	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));
40012000:	92 10 00 1d 	mov  %i5, %o1                                  
40012004:	40 00 2f 72 	call  4001ddcc <rtems_rfs_buffer_setblksize>   
40012008:	90 07 bf 7c 	add  %fp, -132, %o0                            
  if (rc > 0)                                                         
4001200c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012010:	14 80 02 33 	bg  400128dc <rtems_rfs_format+0xa64>          <== NEVER TAKEN
40012014:	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;                                              
40012018:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           
  handle->bnum  = 0;                                                  
4001201c:	c0 27 bf 34 	clr  [ %fp + -204 ]                            
  handle->buffer = NULL;                                              
40012020:	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);       
40012024:	90 07 bf 7c 	add  %fp, -132, %o0                            
40012028:	94 10 20 00 	clr  %o2                                       
4001202c:	40 00 2d fd 	call  4001d820 <rtems_rfs_buffer_handle_request>
40012030:	96 10 20 00 	clr  %o3                                       
  if (rc > 0)                                                         
40012034:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012038:	04 80 00 20 	ble  400120b8 <rtems_rfs_format+0x240>         <== ALWAYS TAKEN
4001203c:	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);                       
40012040:	40 00 2d 7e 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012044:	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",  
40012048:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001204c:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40012050:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
40012054:	40 00 50 94 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012058:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
4001205c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012060:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012064:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012068:	40 00 4c 45 	call  4002517c <printf>                        <== NOT EXECUTED
4001206c:	90 12 23 f0 	or  %o0, 0x3f0, %o0	! 400367f0 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
40012070:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
    return -1;                                                        
40012074:	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");          
40012078:	40 00 4c d9 	call  400253dc <puts>                          <== NOT EXECUTED
4001207c:	90 12 21 20 	or  %o0, 0x120, %o0                            <== NOT EXECUTED
40012080:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012084:	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))
40012088:	80 a0 40 1d 	cmp  %g1, %i5                                  <== NOT EXECUTED
4001208c:	08 bf ff b2 	bleu  40011f54 <rtems_rfs_format+0xdc>         <== NOT EXECUTED
40012090:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
  {                                                                   
    printf ("group block count is higher than bits in block\n");      
40012094:	40 00 4c d2 	call  400253dc <puts>                          <== NOT EXECUTED
40012098:	90 12 21 a8 	or  %o0, 0x1a8, %o0	! 400365a8 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
4001209c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400120a0:	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);                         
400120a4:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
400120a8:	40 00 4c 35 	call  4002517c <printf>                        <== NOT EXECUTED
400120ac:	90 12 20 f8 	or  %o0, 0xf8, %o0	! 400364f8 <_CPU_Trap_slot_template+0x10><== NOT EXECUTED
                                                                      
  memset (&fs, 0, sizeof (rtems_rfs_file_system));                    
400120b0:	10 bf ff 78 	b  40011e90 <rtems_rfs_format+0x18>            <== NOT EXECUTED
400120b4:	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);                               
400120b8:	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));                    
400120bc:	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);                               
400120c0:	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));                    
400120c4:	92 10 20 ff 	mov  0xff, %o1                                 
400120c8:	40 00 4b af 	call  40024f84 <memset>                        
400120cc:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);           
400120d0:	82 10 20 28 	mov  0x28, %g1                                 
400120d4:	c2 2f 40 00 	stb  %g1, [ %i5 ]                              
400120d8:	82 10 20 09 	mov  9, %g1                                    
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
400120dc:	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);           
400120e0:	c2 2f 60 01 	stb  %g1, [ %i5 + 1 ]                          
  write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);          
400120e4:	c0 2f 60 05 	clrb  [ %i5 + 5 ]                              
400120e8:	c0 2f 60 06 	clrb  [ %i5 + 6 ]                              
400120ec:	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);           
400120f0:	84 10 20 01 	mov  1, %g2                                    
400120f4:	82 10 20 20 	mov  0x20, %g1                                 
400120f8:	c4 2f 60 03 	stb  %g2, [ %i5 + 3 ]                          
400120fc:	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));
40012100:	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));    
40012104:	c2 07 bf 80 	ld  [ %fp + -128 ], %g1                        
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40012108:	c6 2f 60 08 	stb  %g3, [ %i5 + 8 ]                          
4001210c:	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));    
40012110:	c2 2f 60 0f 	stb  %g1, [ %i5 + 0xf ]                        
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40012114:	c6 2f 60 09 	stb  %g3, [ %i5 + 9 ]                          
40012118:	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));    
4001211c:	87 30 60 18 	srl  %g1, 0x18, %g3                            
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40012120:	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));    
40012124:	c6 2f 60 0c 	stb  %g3, [ %i5 + 0xc ]                        
  write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
40012128:	c8 2f 60 0a 	stb  %g4, [ %i5 + 0xa ]                        
4001212c:	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);                 
40012130:	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));
40012134:	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));    
40012138:	87 30 60 10 	srl  %g1, 0x10, %g3                            
4001213c:	83 30 60 08 	srl  %g1, 8, %g1                               
40012140:	c6 2f 60 0d 	stb  %g3, [ %i5 + 0xd ]                        
40012144:	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);          
40012148:	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);                 
4001214c:	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);          
40012150:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
40012154:	c2 17 bf 94 	lduh  [ %fp + -108 ], %g1                      
40012158:	c2 2f 60 11 	stb  %g1, [ %i5 + 0x11 ]                       
4001215c:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
40012160:	83 30 60 08 	srl  %g1, 8, %g1                               
40012164:	c2 2f 60 12 	stb  %g1, [ %i5 + 0x12 ]                       
40012168:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
4001216c:	c2 2f 60 13 	stb  %g1, [ %i5 + 0x13 ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
40012170:	c2 0f bf 98 	ldub  [ %fp + -104 ], %g1                      
40012174:	c2 2f 60 14 	stb  %g1, [ %i5 + 0x14 ]                       
40012178:	c2 17 bf 98 	lduh  [ %fp + -104 ], %g1                      
4001217c:	c2 2f 60 15 	stb  %g1, [ %i5 + 0x15 ]                       
40012180:	c2 07 bf 98 	ld  [ %fp + -104 ], %g1                        
40012184:	83 30 60 08 	srl  %g1, 8, %g1                               
40012188:	c2 2f 60 16 	stb  %g1, [ %i5 + 0x16 ]                       
4001218c:	c2 07 bf 98 	ld  [ %fp + -104 ], %g1                        
40012190:	c2 2f 60 17 	stb  %g1, [ %i5 + 0x17 ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);             
40012194:	c2 0f bf a0 	ldub  [ %fp + -96 ], %g1                       
40012198:	c2 2f 60 18 	stb  %g1, [ %i5 + 0x18 ]                       
4001219c:	c2 17 bf a0 	lduh  [ %fp + -96 ], %g1                       
400121a0:	c2 2f 60 19 	stb  %g1, [ %i5 + 0x19 ]                       
400121a4:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
400121a8:	83 30 60 08 	srl  %g1, 8, %g1                               
400121ac:	c2 2f 60 1a 	stb  %g1, [ %i5 + 0x1a ]                       
400121b0:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
400121b4:	c2 2f 60 1b 	stb  %g1, [ %i5 + 0x1b ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);      
400121b8:	c2 0f bf a4 	ldub  [ %fp + -92 ], %g1                       
400121bc:	c2 2f 60 1c 	stb  %g1, [ %i5 + 0x1c ]                       
400121c0:	c2 17 bf a4 	lduh  [ %fp + -92 ], %g1                       
400121c4:	c2 2f 60 1d 	stb  %g1, [ %i5 + 0x1d ]                       
400121c8:	c2 07 bf a4 	ld  [ %fp + -92 ], %g1                         
400121cc:	83 30 60 08 	srl  %g1, 8, %g1                               
400121d0:	c2 2f 60 1e 	stb  %g1, [ %i5 + 0x1e ]                       
400121d4:	c2 07 bf a4 	ld  [ %fp + -92 ], %g1                         
400121d8:	c2 2f 60 1f 	stb  %g1, [ %i5 + 0x1f ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);      
400121dc:	c2 0f bf a8 	ldub  [ %fp + -88 ], %g1                       
400121e0:	c2 2f 60 20 	stb  %g1, [ %i5 + 0x20 ]                       
400121e4:	c2 17 bf a8 	lduh  [ %fp + -88 ], %g1                       
400121e8:	c2 2f 60 21 	stb  %g1, [ %i5 + 0x21 ]                       
400121ec:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
400121f0:	83 30 60 08 	srl  %g1, 8, %g1                               
400121f4:	c2 2f 60 22 	stb  %g1, [ %i5 + 0x22 ]                       
400121f8:	c2 07 bf a8 	ld  [ %fp + -88 ], %g1                         
  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);    
400121fc:	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);      
40012200:	c2 2f 60 23 	stb  %g1, [ %i5 + 0x23 ]                       
  write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);    
40012204:	c0 2f 60 25 	clrb  [ %i5 + 0x25 ]                           
40012208:	c0 2f 60 26 	clrb  [ %i5 + 0x26 ]                           
4001220c:	82 10 20 38 	mov  0x38, %g1                                 
40012210:	c2 2f 60 27 	stb  %g1, [ %i5 + 0x27 ]                       
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  rc = rtems_rfs_buffer_handle_release (fs, &handle);                 
40012214:	40 00 2d 09 	call  4001d638 <rtems_rfs_buffer_handle_release>
40012218:	c4 2f bf 30 	stb  %g2, [ %fp + -208 ]                       
  if (rc > 0)                                                         
4001221c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012220:	04 80 00 e3 	ble  400125ac <rtems_rfs_format+0x734>         <== ALWAYS TAKEN
40012224:	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);                       
40012228:	40 00 2d 04 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001222c:	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",
40012230:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
40012234:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40012238:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
4001223c:	40 00 50 1a 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012240:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
40012244:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012248:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4001224c:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
40012250:	40 00 4b cb 	call  4002517c <printf>                        <== NOT EXECUTED
40012254:	90 12 20 28 	or  %o0, 0x28, %o0	! 40036828 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
    return -1;                                                        
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
40012258:	10 bf ff 87 	b  40012074 <rtems_rfs_format+0x1fc>           <== NOT EXECUTED
4001225c:	11 10 00 db 	sethi  %hi(0x40036c00), %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);               
40012260:	40 00 38 78 	call  40020440 <rtems_rfs_fs_media_size>       
40012264:	90 07 bf 7c 	add  %fp, -132, %o0                            
                                                                      
    if (total_size >= GIGS (1))                                       
40012268:	80 a2 20 00 	cmp  %o0, 0                                    
4001226c:	22 80 00 9f 	be,a   400124e8 <rtems_rfs_format+0x670>       <== ALWAYS TAKEN
40012270:	03 00 03 ff 	sethi  %hi(0xffc00), %g1                       
    {                                                                 
      uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);             
40012274:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
40012278:	37 00 04 00 	sethi  %hi(0x100000), %i3                      <== NOT EXECUTED
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
4001227c:	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);             
40012280:	ba 82 40 1b 	addcc  %o1, %i3, %i5                           <== NOT EXECUTED
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
        if ((gigs & (1 << b)) != 0)                                   
40012284:	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);             
40012288:	b8 42 00 1a 	addx  %o0, %i2, %i4                            <== NOT EXECUTED
4001228c:	85 37 60 14 	srl  %i5, 0x14, %g2                            <== NOT EXECUTED
40012290:	89 2f 20 0c 	sll  %i4, 0xc, %g4                             <== NOT EXECUTED
40012294:	10 80 00 04 	b  400122a4 <rtems_rfs_format+0x42c>           <== NOT EXECUTED
40012298:	84 11 00 02 	or  %g4, %g2, %g2                              <== NOT EXECUTED
      int      b;                                                     
      for (b = 31; b > 0; b--)                                        
4001229c:	02 80 00 06 	be  400122b4 <rtems_rfs_format+0x43c>          <== NOT EXECUTED
400122a0:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
        if ((gigs & (1 << b)) != 0)                                   
400122a4:	bb 28 c0 01 	sll  %g3, %g1, %i5                             <== NOT EXECUTED
400122a8:	80 8f 40 02 	btst  %i5, %g2                                 <== NOT EXECUTED
400122ac:	02 bf ff fc 	be  4001229c <rtems_rfs_format+0x424>          <== NOT EXECUTED
400122b0:	82 80 7f ff 	addcc  %g1, -1, %g1                            <== NOT EXECUTED
          break;                                                      
      fs->block_size = 1 << b;                                        
    }                                                                 
                                                                      
    if (fs->block_size < 512)                                         
400122b4:	80 a7 61 ff 	cmp  %i5, 0x1ff                                <== NOT EXECUTED
400122b8:	18 80 00 94 	bgu  40012508 <rtems_rfs_format+0x690>         <== NOT EXECUTED
400122bc:	fa 27 bf 84 	st  %i5, [ %fp + -124 ]                        <== NOT EXECUTED
400122c0:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        <== NOT EXECUTED
      fs->block_size = 512;                                           
400122c4:	ba 10 22 00 	mov  0x200, %i5                                
400122c8:	f8 00 60 20 	ld  [ %g1 + 0x20 ], %i4                        
400122cc:	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)     
400122d0:	90 10 00 1d 	mov  %i5, %o0                                  
          break;                                                      
      fs->block_size = 1 << b;                                        
    }                                                                 
                                                                      
    if (fs->block_size < 512)                                         
      fs->block_size = 512;                                           
400122d4:	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)     
400122d8:	40 00 7d 3f 	call  400317d4 <.urem>                         
400122dc:	92 10 00 1c 	mov  %i4, %o1                                  
400122e0:	80 a2 20 00 	cmp  %o0, 0                                    
400122e4:	22 bf ff 17 	be,a   40011f40 <rtems_rfs_format+0xc8>        <== ALWAYS TAKEN
400122e8:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
  {                                                                   
    printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
400122ec:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400122f0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
400122f4:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
400122f8:	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",
400122fc:	40 00 4b a0 	call  4002517c <printf>                        <== NOT EXECUTED
40012300:	90 12 21 68 	or  %o0, 0x168, %o0                            <== NOT EXECUTED
40012304:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012308:	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",          
4001230c:	40 00 38 4d 	call  40020440 <rtems_rfs_fs_media_size>       <== NOT EXECUTED
40012310:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
40012314:	94 10 00 09 	mov  %o1, %o2                                  <== NOT EXECUTED
40012318:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4001231c:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012320:	40 00 4b 97 	call  4002517c <printf>                        <== NOT EXECUTED
40012324:	90 12 21 d8 	or  %o0, 0x1d8, %o0	! 400365d8 <_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));                         
40012328:	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",        
4001232c:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012330:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        <== NOT EXECUTED
40012334:	40 00 4b 92 	call  4002517c <printf>                        <== NOT EXECUTED
40012338:	90 12 22 00 	or  %o0, 0x200, %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));                     
4001233c:	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",    
40012340:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012344:	d2 00 60 20 	ld  [ %g1 + 0x20 ], %o1                        <== NOT EXECUTED
40012348:	40 00 4b 8d 	call  4002517c <printf>                        <== NOT EXECUTED
4001234c:	90 12 22 28 	or  %o0, 0x228, %o0                            <== NOT EXECUTED
            rtems_rfs_fs_media_block_size (&fs));                     
    printf ("rtems-rfs: format: size = %" PRIu64 "\n",                
40012350:	40 00 38 33 	call  4002041c <rtems_rfs_fs_size>             <== NOT EXECUTED
40012354:	90 07 bf 7c 	add  %fp, -132, %o0                            <== NOT EXECUTED
40012358:	94 10 00 09 	mov  %o1, %o2                                  <== NOT EXECUTED
4001235c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40012360:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012364:	40 00 4b 86 	call  4002517c <printf>                        <== NOT EXECUTED
40012368:	90 12 22 58 	or  %o0, 0x258, %o0	! 40036658 <_CPU_Trap_slot_template+0x170><== NOT EXECUTED
            rtems_rfs_fs_size (&fs));                                 
    printf ("rtems-rfs: format: blocks = %zu\n",                      
4001236c:	d2 07 bf 80 	ld  [ %fp + -128 ], %o1                        <== NOT EXECUTED
40012370:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012374:	40 00 4b 82 	call  4002517c <printf>                        <== NOT EXECUTED
40012378:	90 12 22 78 	or  %o0, 0x278, %o0	! 40036678 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
            rtems_rfs_fs_blocks (&fs));                               
    printf ("rtems-rfs: format: block size = %zu\n",                  
4001237c:	d2 07 bf 84 	ld  [ %fp + -124 ], %o1                        <== NOT EXECUTED
40012380:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012384:	40 00 4b 7e 	call  4002517c <printf>                        <== NOT EXECUTED
40012388:	90 12 22 a0 	or  %o0, 0x2a0, %o0	! 400366a0 <_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));  
4001238c:	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",               
40012390:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012394:	93 2a 60 03 	sll  %o1, 3, %o1                               <== NOT EXECUTED
40012398:	40 00 4b 79 	call  4002517c <printf>                        <== NOT EXECUTED
4001239c:	90 12 22 c8 	or  %o0, 0x2c8, %o0                            <== NOT EXECUTED
            rtems_rfs_bits_per_block (&fs));                          
    printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
400123a0:	92 10 20 38 	mov  0x38, %o1                                 <== NOT EXECUTED
400123a4:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
400123a8:	40 00 4b 75 	call  4002517c <printf>                        <== NOT EXECUTED
400123ac:	90 12 22 f0 	or  %o0, 0x2f0, %o0	! 400366f0 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
    printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",            
400123b0:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         <== NOT EXECUTED
            fs.group_inodes * fs.group_count,                         
400123b4:	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",            
400123b8:	7f ff c0 80 	call  400025b8 <.umul>                         <== NOT EXECUTED
400123bc:	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,
400123c0:	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",            
400123c4:	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,
400123c8:	bb 2f 60 06 	sll  %i5, 6, %i5                               <== NOT EXECUTED
                                  rtems_rfs_fs_block_size (fs));      
400123cc:	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)                                                  
400123d0:	ba a7 40 01 	subcc  %i5, %g1, %i5                           <== NOT EXECUTED
400123d4:	12 80 00 55 	bne  40012528 <rtems_rfs_format+0x6b0>         <== NOT EXECUTED
400123d8:	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))
400123dc:	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));  
400123e0:	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))
400123e4:	92 00 7f ff 	add  %g1, -1, %o1                              <== NOT EXECUTED
400123e8:	80 a7 00 09 	cmp  %i4, %o1                                  <== NOT EXECUTED
400123ec:	28 80 00 02 	bleu,a   400123f4 <rtems_rfs_format+0x57c>     <== NOT EXECUTED
400123f0:	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;                  
400123f4:	7f ff c0 ad 	call  400026a8 <.div>                          <== NOT EXECUTED
400123f8:	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",            
400123fc:	92 10 20 0a 	mov  0xa, %o1	! a <PROM_START+0xa>             <== NOT EXECUTED
40012400:	7f ff c0 aa 	call  400026a8 <.div>                          <== NOT EXECUTED
40012404:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
40012408:	92 10 20 0a 	mov  0xa, %o1                                  <== NOT EXECUTED
4001240c:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
40012410:	40 00 7c f3 	call  400317dc <.rem>                          <== NOT EXECUTED
40012414:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40012418:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
4001241c:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
40012420:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40012424:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012428:	40 00 4b 55 	call  4002517c <printf>                        <== NOT EXECUTED
4001242c:	90 12 23 18 	or  %o0, 0x318, %o0	! 40036718 <_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);      
40012430:	d2 07 bf a0 	ld  [ %fp + -96 ], %o1                         <== NOT EXECUTED
40012434:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012438:	40 00 4b 51 	call  4002517c <printf>                        <== NOT EXECUTED
4001243c:	90 12 23 48 	or  %o0, 0x348, %o0	! 40036748 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
    printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
40012440:	d2 07 bf a4 	ld  [ %fp + -92 ], %o1                         <== NOT EXECUTED
40012444:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012448:	40 00 4b 4d 	call  4002517c <printf>                        <== NOT EXECUTED
4001244c:	90 12 23 68 	or  %o0, 0x368, %o0	! 40036768 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
    printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
40012450:	d2 07 bf a8 	ld  [ %fp + -88 ], %o1                         <== NOT EXECUTED
40012454:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012458:	40 00 4b 49 	call  4002517c <printf>                        <== NOT EXECUTED
4001245c:	90 12 23 90 	or  %o0, 0x390, %o0	! 40036790 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
40012460:	10 bf fe e8 	b  40012000 <rtems_rfs_format+0x188>           <== NOT EXECUTED
40012464:	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)                                           
40012468:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4001246c:	02 bf fe df 	be  40011fe8 <rtems_rfs_format+0x170>          <== NOT EXECUTED
40012470:	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;                      
40012474:	10 bf fe df 	b  40011ff0 <rtems_rfs_format+0x178>           <== NOT EXECUTED
40012478:	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)                                       
4001247c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
40012480:	80 a0 60 00 	cmp  %g1, 0                                    
40012484:	02 80 00 03 	be  40012490 <rtems_rfs_format+0x618>          <== ALWAYS TAKEN
40012488:	90 10 20 01 	mov  1, %o0                                    
4001248c:	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;          
40012490:	7f ff c0 4a 	call  400025b8 <.umul>                         
40012494:	92 07 3f ff 	add  %i4, -1, %o1                              
40012498:	92 10 20 64 	mov  0x64, %o1                                 
4001249c:	7f ff c0 81 	call  400026a0 <.udiv>                         
400124a0:	b6 10 20 01 	mov  1, %i3                                    
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
400124a4:	80 a2 20 00 	cmp  %o0, 0                                    
400124a8:	32 80 00 30 	bne,a   40012568 <rtems_rfs_format+0x6f0>      
400124ac:	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);
400124b0:	92 10 20 38 	mov  0x38, %o1                                 
400124b4:	7f ff c0 7b 	call  400026a0 <.udiv>                         
400124b8:	90 10 00 1d 	mov  %i5, %o0                                  
400124bc:	b8 10 00 08 	mov  %o0, %i4                                  
400124c0:	90 10 00 1b 	mov  %i3, %o0                                  
400124c4:	7f ff c0 3d 	call  400025b8 <.umul>                         
400124c8:	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;
400124cc:	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);
400124d0:	b6 10 00 08 	mov  %o0, %i3                                  
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
400124d4:	80 a6 e0 00 	cmp  %i3, 0                                    
400124d8:	02 bf fe bc 	be  40011fc8 <rtems_rfs_format+0x150>          <== NEVER TAKEN
400124dc:	90 10 20 01 	mov  1, %o0                                    
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
400124e0:	10 bf fe b7 	b  40011fbc <rtems_rfs_format+0x144>           
400124e4:	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))                                       
400124e8:	82 10 63 ff 	or  %g1, 0x3ff, %g1                            
400124ec:	80 a2 40 01 	cmp  %o1, %g1                                  
400124f0:	18 bf ff 62 	bgu  40012278 <rtems_rfs_format+0x400>         <== NEVER TAKEN
400124f4:	b4 10 20 00 	clr  %i2                                       
400124f8:	fa 07 bf 84 	ld  [ %fp + -124 ], %i5                        
        if ((gigs & (1 << b)) != 0)                                   
          break;                                                      
      fs->block_size = 1 << b;                                        
    }                                                                 
                                                                      
    if (fs->block_size < 512)                                         
400124fc:	80 a7 61 ff 	cmp  %i5, 0x1ff                                
40012500:	08 bf ff 71 	bleu  400122c4 <rtems_rfs_format+0x44c>        <== ALWAYS TAKEN
40012504:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        
      fs->block_size = 512;                                           
                                                                      
    if (fs->block_size > (4 * 1024))                                  
40012508:	03 00 00 04 	sethi  %hi(0x1000), %g1                        <== NOT EXECUTED
4001250c:	80 a7 40 01 	cmp  %i5, %g1                                  <== NOT EXECUTED
40012510:	08 80 02 06 	bleu  40012d28 <rtems_rfs_format+0xeb0>        <== NOT EXECUTED
40012514:	c4 07 bf 8c 	ld  [ %fp + -116 ], %g2                        <== NOT EXECUTED
      fs->block_size = (4 * 1024);                                    
40012518:	c2 27 bf 84 	st  %g1, [ %fp + -124 ]                        <== NOT EXECUTED
4001251c:	f8 00 a0 20 	ld  [ %g2 + 0x20 ], %i4                        <== NOT EXECUTED
40012520:	10 bf fe 81 	b  40011f24 <rtems_rfs_format+0xac>            <== NOT EXECUTED
40012524:	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;                              
40012528:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001252c:	7f ff c0 5d 	call  400026a0 <.udiv>                         <== NOT EXECUTED
40012530:	90 07 7f ff 	add  %i5, -1, %o0                              <== NOT EXECUTED
40012534:	90 02 20 02 	add  %o0, 2, %o0                               <== NOT EXECUTED
40012538:	83 2a 20 02 	sll  %o0, 2, %g1                               <== NOT EXECUTED
4001253c:	85 2a 20 07 	sll  %o0, 7, %g2                               <== NOT EXECUTED
40012540:	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))
40012544:	c2 07 bf 80 	ld  [ %fp + -128 ], %g1                        <== NOT EXECUTED
40012548:	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));  
4001254c:	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))
40012550:	92 00 7f ff 	add  %g1, -1, %o1                              <== NOT EXECUTED
40012554:	80 a7 00 09 	cmp  %i4, %o1                                  <== NOT EXECUTED
40012558:	18 bf ff a7 	bgu  400123f4 <rtems_rfs_format+0x57c>         <== NOT EXECUTED
4001255c:	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));  
40012560:	10 bf ff a5 	b  400123f4 <rtems_rfs_format+0x57c>           <== NOT EXECUTED
40012564:	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;                              
40012568:	7f ff c0 4e 	call  400026a0 <.udiv>                         
4001256c:	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);
40012570:	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;                              
40012574:	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);
40012578:	7f ff c0 4a 	call  400026a0 <.udiv>                         
4001257c:	90 10 00 1d 	mov  %i5, %o0                                  
40012580:	b8 10 00 08 	mov  %o0, %i4                                  
40012584:	90 10 00 1b 	mov  %i3, %o0                                  
40012588:	7f ff c0 0c 	call  400025b8 <.umul>                         
4001258c:	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;
40012590:	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);
40012594:	b6 10 00 08 	mov  %o0, %i3                                  
 * "quotient = dividend / divisor"                                    
 */                                                                   
int                                                                   
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)          
{                                                                     
  if (dividend == 0)                                                  
40012598:	80 a6 e0 00 	cmp  %i3, 0                                    
4001259c:	02 bf fe 8b 	be  40011fc8 <rtems_rfs_format+0x150>          <== NEVER TAKEN
400125a0:	90 10 20 01 	mov  1, %o0                                    
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
400125a4:	10 bf fe 86 	b  40011fbc <rtems_rfs_format+0x144>           
400125a8:	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);                       
400125ac:	90 07 bf 7c 	add  %fp, -132, %o0                            
400125b0:	40 00 2c 22 	call  4001d638 <rtems_rfs_buffer_handle_release>
400125b4:	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++)                    
400125b8:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
400125bc:	80 a0 60 00 	cmp  %g1, 0                                    
400125c0:	04 80 01 36 	ble  40012a98 <rtems_rfs_format+0xc20>         <== NEVER TAKEN
400125c4:	c2 07 bf 80 	ld  [ %fp + -128 ], %g1                        
    if (!rtems_rfs_write_group (&fs, group,                           
400125c8:	e2 0e 60 14 	ldub  [ %i1 + 0x14 ], %l1                      
400125cc:	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))                          
400125d0:	80 a0 60 00 	cmp  %g1, 0                                    
400125d4:	02 80 01 2f 	be  40012a90 <rtems_rfs_format+0xc18>          <== NEVER TAKEN
400125d8:	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",
400125dc:	27 10 00 da 	sethi  %hi(0x40036800), %l3                    
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  if (verbose)                                                        
    printf (", blocks");                                              
400125e0:	25 10 00 da 	sethi  %hi(0x40036800), %l2                    
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  if (verbose)                                                        
    printf (", inodes");                                              
400125e4:	2b 10 00 da 	sethi  %hi(0x40036800), %l5                    
  int                      b;                                         
  int                      rc;                                        
                                                                      
  group_base = rtems_rfs_fs_block (fs, group, 0);                     
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
400125e8:	b6 10 20 01 	mov  1, %i3                                    
400125ec:	a0 10 20 00 	clr  %l0                                       
400125f0:	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",
400125f4:	a6 14 e0 a8 	or  %l3, 0xa8, %l3                             
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  if (verbose)                                                        
    printf (", blocks");                                              
400125f8:	a4 14 a0 e0 	or  %l2, 0xe0, %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);                              
400125fc:	a8 10 20 01 	mov  1, %l4                                    
                                                                      
  if (verbose)                                                        
    printf (", inodes");                                              
40012600:	aa 15 61 d0 	or  %l5, 0x1d0, %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))           
40012604:	86 06 c0 1c 	add  %i3, %i4, %g3                             
40012608:	80 a0 c0 01 	cmp  %g3, %g1                                  
4001260c:	38 80 00 02 	bgu,a   40012614 <rtems_rfs_format+0x79c>      <== ALWAYS TAKEN
40012610:	b8 20 40 1b 	sub  %g1, %i3, %i4                             
    group_size = rtems_rfs_fs_blocks (fs) - group_base;               
                                                                      
  if (verbose)                                                        
40012614:	ac 88 a0 ff 	andcc  %g2, 0xff, %l6                          
40012618:	12 80 00 3b 	bne  40012704 <rtems_rfs_format+0x88c>         <== NEVER TAKEN
4001261c:	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;                                              
40012620:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           
  handle->bnum  = 0;                                                  
40012624:	c0 27 bf 34 	clr  [ %fp + -204 ]                            
  handle->buffer = NULL;                                              
40012628:	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,       
4001262c:	90 07 bf 3c 	add  %fp, -196, %o0                            
40012630:	92 07 bf 7c 	add  %fp, -132, %o1                            
40012634:	94 07 bf 30 	add  %fp, -208, %o2                            
40012638:	96 10 00 1c 	mov  %i4, %o3                                  
4001263c:	40 00 27 66 	call  4001c3d4 <rtems_rfs_bitmap_open>         
40012640:	98 10 00 1b 	mov  %i3, %o4                                  
                              group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
40012644:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012648:	04 80 00 12 	ble  40012690 <rtems_rfs_format+0x818>         <== ALWAYS TAKEN
4001264c:	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);                       
40012650:	40 00 2b fa 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012654:	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",
40012658:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001265c:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40012660:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
40012664:	40 00 4f 10 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012668:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
4001266c:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40012670:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
40012674:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
40012678:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
4001267c:	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",
40012680:	40 00 4a bf 	call  4002517c <printf>                        <== NOT EXECUTED
40012684:	90 12 20 f0 	or  %o0, 0xf0, %o0                             <== NOT EXECUTED
40012688:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001268c:	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));
40012690:	c2 07 bf 38 	ld  [ %fp + -200 ], %g1                        
40012694:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        
40012698:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
4001269c:	40 00 4a 3a 	call  40024f84 <memset>                        
400126a0:	92 10 20 ff 	mov  0xff, %o1                                 
                                                                      
  /*                                                                  
   * Clear the bitmap.                                                
   */                                                                 
  rc = rtems_rfs_bitmap_map_clear_all (&bitmap);                      
400126a4:	40 00 26 a4 	call  4001c134 <rtems_rfs_bitmap_map_clear_all>
400126a8:	90 07 bf 3c 	add  %fp, -196, %o0                            
  if (rc > 0)                                                         
400126ac:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400126b0:	04 80 00 20 	ble  40012730 <rtems_rfs_format+0x8b8>         <== ALWAYS TAKEN
400126b4:	92 10 20 00 	clr  %o1                                       
  {                                                                   
    rtems_rfs_bitmap_close (&bitmap);                                 
400126b8:	40 00 27 58 	call  4001c418 <rtems_rfs_bitmap_close>        <== NOT EXECUTED
400126bc:	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);                       
400126c0:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
400126c4:	40 00 2b dd 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400126c8:	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",
400126cc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400126d0:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400126d4:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
400126d8:	40 00 4e f3 	call  400262a4 <strerror>                      <== NOT EXECUTED
400126dc:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
400126e0:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
400126e4:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
400126e8:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
400126ec:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
400126f0:	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",
400126f4:	40 00 4a a2 	call  4002517c <printf>                        <== NOT EXECUTED
400126f8:	90 12 21 38 	or  %o0, 0x138, %o0                            <== NOT EXECUTED
400126fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012700:	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",
40012704:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40012708:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
4001270c:	40 00 4a 9c 	call  4002517c <printf>                        <== NOT EXECUTED
40012710:	96 10 00 1c 	mov  %i4, %o3                                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    return false;                                                     
  }                                                                   
                                                                      
  if (verbose)                                                        
    printf (", blocks");                                              
40012714:	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;                                              
40012718:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
4001271c:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
40012720:	40 00 4a 97 	call  4002517c <printf>                        <== NOT EXECUTED
40012724:	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,       
40012728:	10 bf ff c2 	b  40012630 <rtems_rfs_format+0x7b8>           <== NOT EXECUTED
4001272c:	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);
40012730:	40 00 25 fa 	call  4001bf18 <rtems_rfs_bitmap_map_set>      
40012734:	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);
40012738:	92 10 20 01 	mov  1, %o1                                    
4001273c:	40 00 25 f7 	call  4001bf18 <rtems_rfs_bitmap_map_set>      
40012740:	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);
40012744:	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)                                                  
40012748:	80 a2 20 00 	cmp  %o0, 0                                    
4001274c:	12 80 00 2b 	bne  400127f8 <rtems_rfs_format+0x980>         <== ALWAYS TAKEN
40012750:	d2 07 bf ac 	ld  [ %fp + -84 ], %o1                         
    return 1;                                                         
40012754:	ae 10 20 01 	mov  1, %l7                                    <== NOT EXECUTED
40012758:	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);
4001275c:	92 07 60 02 	add  %i5, 2, %o1                               
40012760:	40 00 25 ee 	call  4001bf18 <rtems_rfs_bitmap_map_set>      
40012764:	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++)                                        
40012768:	ba 07 60 01 	inc  %i5                                       
4001276c:	80 a7 40 17 	cmp  %i5, %l7                                  
40012770:	06 bf ff fc 	bl  40012760 <rtems_rfs_format+0x8e8>          
40012774:	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);                              
40012778:	40 00 27 28 	call  4001c418 <rtems_rfs_bitmap_close>        
4001277c:	90 07 bf 3c 	add  %fp, -196, %o0                            
  if (rc > 0)                                                         
40012780:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012784:	14 80 00 24 	bg  40012814 <rtems_rfs_format+0x99c>          <== NEVER TAKEN
40012788:	80 a5 a0 00 	cmp  %l6, 0                                    
    return false;                                                     
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  if (verbose)                                                        
4001278c:	12 80 00 50 	bne  400128cc <rtems_rfs_format+0xa54>         <== NEVER TAKEN
40012790:	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,       
40012794:	90 07 bf 3c 	add  %fp, -196, %o0                            
40012798:	92 07 bf 7c 	add  %fp, -132, %o1                            
4001279c:	94 07 bf 30 	add  %fp, -208, %o2                            
400127a0:	96 10 00 1c 	mov  %i4, %o3                                  
400127a4:	40 00 27 0c 	call  4001c3d4 <rtems_rfs_bitmap_open>         
400127a8:	98 04 20 02 	add  %l0, 2, %o4                               
                              group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
  if (rc > 0)                                                         
400127ac:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400127b0:	04 80 00 2a 	ble  40012858 <rtems_rfs_format+0x9e0>         <== ALWAYS TAKEN
400127b4:	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);                       
400127b8:	40 00 2b a0 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400127bc:	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",
400127c0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400127c4:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400127c8:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
400127cc:	40 00 4e b6 	call  400262a4 <strerror>                      <== NOT EXECUTED
400127d0:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
400127d4:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
400127d8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
400127dc:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
400127e0:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
400127e4:	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",
400127e8:	40 00 4a 65 	call  4002517c <printf>                        <== NOT EXECUTED
400127ec:	90 12 21 e0 	or  %o0, 0x1e0, %o0                            <== NOT EXECUTED
400127f0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400127f4:	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;                              
400127f8:	7f ff bf aa 	call  400026a0 <.udiv>                         
400127fc:	90 02 3f ff 	add  %o0, -1, %o0                              
40012800:	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++)                                        
40012804:	80 a5 e0 00 	cmp  %l7, 0                                    
40012808:	14 bf ff d5 	bg  4001275c <rtems_rfs_format+0x8e4>          <== ALWAYS TAKEN
4001280c:	ba 10 20 00 	clr  %i5                                       
40012810:	30 bf ff da 	b,a   40012778 <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);                       
40012814:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
40012818:	40 00 2b 88 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001281c:	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",
40012820:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
40012824:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40012828:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
4001282c:	40 00 4e 9e 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012830:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
40012834:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40012838:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
4001283c:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
40012840:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
40012844:	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",
40012848:	40 00 4a 4d 	call  4002517c <printf>                        <== NOT EXECUTED
4001284c:	90 12 21 88 	or  %o0, 0x188, %o0                            <== NOT EXECUTED
40012850:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012854:	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));
40012858:	c2 07 bf 38 	ld  [ %fp + -200 ], %g1                        
4001285c:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        
40012860:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        
40012864:	40 00 49 c8 	call  40024f84 <memset>                        
40012868:	92 10 20 00 	clr  %o1                                       
                                                                      
  /*                                                                  
   * Clear the inode bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_map_clear_all (&bitmap);                      
4001286c:	40 00 26 32 	call  4001c134 <rtems_rfs_bitmap_map_clear_all>
40012870:	90 07 bf 3c 	add  %fp, -196, %o0                            
40012874:	ba 10 00 08 	mov  %o0, %i5                                  
  if (rc > 0)                                                         
40012878:	80 a7 60 00 	cmp  %i5, 0                                    
4001287c:	04 80 00 21 	ble  40012900 <rtems_rfs_format+0xa88>         <== ALWAYS TAKEN
40012880:	90 07 bf 3c 	add  %fp, -196, %o0                            
  {                                                                   
    rtems_rfs_bitmap_close (&bitmap);                                 
40012884:	40 00 26 e5 	call  4001c418 <rtems_rfs_bitmap_close>        <== NOT EXECUTED
40012888:	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);                       
4001288c:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
40012890:	40 00 2b 6a 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012894:	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" \     
40012898:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
4001289c:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400128a0:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
400128a4:	40 00 4e 80 	call  400262a4 <strerror>                      <== NOT EXECUTED
400128a8:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
400128ac:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
400128b0:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
400128b4:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
400128b8:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
400128bc:	40 00 4a 30 	call  4002517c <printf>                        <== NOT EXECUTED
400128c0:	90 12 22 28 	or  %o0, 0x228, %o0	! 40036a28 <_CPU_Trap_slot_template+0x540><== NOT EXECUTED
400128c4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400128c8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_buffer_mark_dirty (&handle);                              
                                                                      
  if (verbose)                                                        
    printf (", inodes");                                              
400128cc:	40 00 4a 2c 	call  4002517c <printf>                        <== NOT EXECUTED
400128d0:	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,       
400128d4:	10 bf ff b1 	b  40012798 <rtems_rfs_format+0x920>           <== NOT EXECUTED
400128d8:	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", 
400128dc:	40 00 4e 72 	call  400262a4 <strerror>                      <== NOT EXECUTED
400128e0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400128e4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400128e8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
400128ec:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
400128f0:	40 00 4a 23 	call  4002517c <printf>                        <== NOT EXECUTED
400128f4:	90 12 23 b8 	or  %o0, 0x3b8, %o0	! 400367b8 <_CPU_Trap_slot_template+0x2d0><== NOT EXECUTED
400128f8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400128fc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  }                                                                   
                                                                      
  /*                                                                  
   * Close the inode bitmap.                                          
   */                                                                 
  rc = rtems_rfs_bitmap_close (&bitmap);                              
40012900:	40 00 26 c6 	call  4001c418 <rtems_rfs_bitmap_close>        
40012904:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
40012908:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001290c:	14 80 00 2a 	bg  400129b4 <rtems_rfs_format+0xb3c>          <== NEVER TAKEN
40012910:	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)                                              
40012914:	02 80 00 46 	be  40012a2c <rtems_rfs_format+0xbb4>          <== ALWAYS TAKEN
40012918:	e8 2f bf 30 	stb  %l4, [ %fp + -208 ]                       
  {                                                                   
    for (b = 0; b < blocks; b++)                                      
4001291c:	80 a5 e0 00 	cmp  %l7, 0                                    <== NOT EXECUTED
40012920:	04 80 00 43 	ble  40012a2c <rtems_rfs_format+0xbb4>         <== NOT EXECUTED
40012924:	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)
40012928:	10 80 00 0a 	b  40012950 <rtems_rfs_format+0xad8>           <== NOT EXECUTED
4001292c:	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));
40012930:	c2 07 bf 38 	ld  [ %fp + -200 ], %g1                        <== NOT EXECUTED
40012934:	d4 07 bf 84 	ld  [ %fp + -124 ], %o2                        <== NOT EXECUTED
40012938:	d0 00 60 1c 	ld  [ %g1 + 0x1c ], %o0                        <== NOT EXECUTED
4001293c:	40 00 49 92 	call  40024f84 <memset>                        <== NOT EXECUTED
40012940:	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++)                                      
40012944:	80 a6 c0 17 	cmp  %i3, %l7                                  <== NOT EXECUTED
40012948:	02 80 00 39 	be  40012a2c <rtems_rfs_format+0xbb4>          <== NOT EXECUTED
4001294c:	e8 2f bf 30 	stb  %l4, [ %fp + -208 ]                       <== NOT EXECUTED
    {                                                                 
      rc = rtems_rfs_buffer_handle_request (fs, &handle,              
40012950:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
40012954:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
40012958:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
4001295c:	40 00 2b b1 	call  4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40012960:	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));
40012964:	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)                                                     
40012968:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4001296c:	04 bf ff f1 	ble  40012930 <rtems_rfs_format+0xab8>         <== NOT EXECUTED
40012970:	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);                       
40012974:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
40012978:	40 00 2b 30 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
4001297c:	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",
40012980:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
40012984:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40012988:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
4001298c:	40 00 4e 46 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012990:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
40012994:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40012998:	98 10 00 08 	mov  %o0, %o4                                  <== NOT EXECUTED
4001299c:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
400129a0:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
400129a4:	96 10 00 1d 	mov  %i5, %o3                                  <== NOT EXECUTED
400129a8:	40 00 49 f5 	call  4002517c <printf>                        <== NOT EXECUTED
400129ac:	90 12 22 c0 	or  %o0, 0x2c0, %o0                            <== NOT EXECUTED
400129b0:	30 bf fd bb 	b,a   4001209c <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);                       
400129b4:	92 07 bf 30 	add  %fp, -208, %o1                            <== NOT EXECUTED
400129b8:	40 00 2b 20 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400129bc:	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" \      
400129c0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400129c4:	c0 2f bf 30 	clrb  [ %fp + -208 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400129c8:	c0 27 bf 34 	clr  [ %fp + -204 ]                            <== NOT EXECUTED
400129cc:	40 00 4e 36 	call  400262a4 <strerror>                      <== NOT EXECUTED
400129d0:	c0 27 bf 38 	clr  [ %fp + -200 ]                            <== NOT EXECUTED
400129d4:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
400129d8:	96 10 00 08 	mov  %o0, %o3                                  <== NOT EXECUTED
400129dc:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
400129e0:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
400129e4:	40 00 49 e6 	call  4002517c <printf>                        <== NOT EXECUTED
400129e8:	90 12 22 78 	or  %o0, 0x278, %o0	! 40036a78 <_CPU_Trap_slot_template+0x590><== NOT EXECUTED
400129ec:	30 bf fd ac 	b,a   4001209c <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",        
400129f0:	40 00 4e 2d 	call  400262a4 <strerror>                      <== NOT EXECUTED
400129f4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400129f8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400129fc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012a00:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
40012a04:	40 00 49 de 	call  4002517c <printf>                        <== NOT EXECUTED
40012a08:	90 12 21 10 	or  %o0, 0x110, %o0	! 40036510 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
40012a0c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012a10:	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",       
40012a14:	11 10 00 d9 	sethi  %hi(0x40036400), %o0                    <== NOT EXECUTED
            rtems_rfs_fs_media_block_size (&fs));                     
    return -1;                                                        
40012a18:	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",       
40012a1c:	40 00 49 d8 	call  4002517c <printf>                        <== NOT EXECUTED
40012a20:	90 12 21 40 	or  %o0, 0x140, %o0                            <== NOT EXECUTED
40012a24:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012a28:	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);                       
40012a2c:	90 07 bf 7c 	add  %fp, -132, %o0                            
40012a30:	40 00 2b 02 	call  4001d638 <rtems_rfs_buffer_handle_release>
40012a34:	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++)                    
40012a38:	c2 07 bf a0 	ld  [ %fp + -96 ], %g1                         
40012a3c:	b4 06 a0 01 	inc  %i2                                       
40012a40:	80 a0 40 1a 	cmp  %g1, %i2                                  
40012a44:	04 80 00 15 	ble  40012a98 <rtems_rfs_format+0xc20>         <== ALWAYS TAKEN
40012a48:	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);                     
40012a4c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
40012a50:	7f ff be da 	call  400025b8 <.umul>                         <== NOT EXECUTED
40012a54:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
                                                                      
  if (group_base > rtems_rfs_fs_blocks (fs))                          
40012a58:	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);                     
40012a5c:	b6 02 20 01 	add  %o0, 1, %i3                               <== NOT EXECUTED
40012a60:	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,                           
40012a64:	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))                          
40012a68:	80 a6 c0 01 	cmp  %i3, %g1                                  <== NOT EXECUTED
40012a6c:	08 bf fe e6 	bleu  40012604 <rtems_rfs_format+0x78c>        <== NOT EXECUTED
40012a70:	c4 0e 60 15 	ldub  [ %i1 + 0x15 ], %g2                      <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
40012a74:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40012a78:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (!rtems_rfs_write_superblock (&fs))                              
  {                                                                   
    printf ("rtems-rfs: format: superblock write failed\n");          
    return -1;                                                        
40012a7c:	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",
40012a80:	40 00 49 bf 	call  4002517c <printf>                        <== NOT EXECUTED
40012a84:	90 12 20 68 	or  %o0, 0x68, %o0                             <== NOT EXECUTED
40012a88:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012a8c:	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))                          
40012a90:	10 bf ff f9 	b  40012a74 <rtems_rfs_format+0xbfc>           <== NOT EXECUTED
40012a94:	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)                                                
40012a98:	c2 0e 60 15 	ldub  [ %i1 + 0x15 ], %g1                      
40012a9c:	80 a0 60 00 	cmp  %g1, 0                                    
40012aa0:	02 80 00 04 	be  40012ab0 <rtems_rfs_format+0xc38>          <== ALWAYS TAKEN
40012aa4:	01 00 00 00 	nop                                            
    printf ("\n");                                                    
40012aa8:	40 00 4a 1f 	call  40025324 <putchar>                       <== NOT EXECUTED
40012aac:	90 10 20 0a 	mov  0xa, %o0	! a <PROM_START+0xa>             <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_buffer_close (&fs);                                  
40012ab0:	40 00 2d 10 	call  4001def0 <rtems_rfs_buffer_close>        
40012ab4:	90 07 bf 7c 	add  %fp, -132, %o0                            
  if (rc > 0)                                                         
40012ab8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012abc:	14 80 00 43 	bg  40012bc8 <rtems_rfs_format+0xd50>          <== NEVER TAKEN
40012ac0:	92 10 20 00 	clr  %o1                                       
  int                    rc;                                          
                                                                      
  /*                                                                  
   * External API so returns -1.                                      
   */                                                                 
  rc = rtems_rfs_fs_open (name, NULL,                                 
40012ac4:	90 10 00 18 	mov  %i0, %o0                                  
40012ac8:	94 10 20 06 	mov  6, %o2                                    
40012acc:	96 10 20 00 	clr  %o3                                       
40012ad0:	40 00 36 66 	call  40020468 <rtems_rfs_fs_open>             
40012ad4:	98 07 bf 28 	add  %fp, -216, %o4                            
                          RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
                          0, &fs);                                    
  if (rc < 0)                                                         
40012ad8:	80 a2 20 00 	cmp  %o0, 0                                    
40012adc:	06 80 00 7b 	bl  40012cc8 <rtems_rfs_format+0xe50>          <== NEVER TAKEN
40012ae0:	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);          
40012ae4:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
40012ae8:	40 00 02 8c 	call  40013518 <rtems_rfs_inode_alloc>         
40012aec:	94 07 bf 2c 	add  %fp, -212, %o2                            
  if (rc > 0)                                                         
40012af0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012af4:	14 80 00 0c 	bg  40012b24 <rtems_rfs_format+0xcac>          <== NEVER TAKEN
40012af8:	d2 07 bf 2c 	ld  [ %fp + -212 ], %o1                        
            rc, strerror (rc));                                       
    rtems_rfs_fs_close (fs);                                          
    return rc;                                                        
  }                                                                   
                                                                      
  if (ino != RTEMS_RFS_ROOT_INO)                                      
40012afc:	80 a2 60 01 	cmp  %o1, 1                                    
40012b00:	02 80 00 1c 	be  40012b70 <rtems_rfs_format+0xcf8>          <== ALWAYS TAKEN
40012b04:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    
  {                                                                   
    printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
40012b08:	40 00 49 9d 	call  4002517c <printf>                        <== NOT EXECUTED
40012b0c:	90 12 23 a8 	or  %o0, 0x3a8, %o0	! 40036ba8 <_CPU_Trap_slot_template+0x6c0><== NOT EXECUTED
    rtems_rfs_fs_close (fs);                                          
40012b10:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
40012b14:	40 00 38 81 	call  40020d18 <rtems_rfs_fs_close>            <== NOT EXECUTED
40012b18:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40012b1c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012b20:	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",   
40012b24:	40 00 4d e0 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012b28:	01 00 00 00 	nop                                            <== NOT EXECUTED
40012b2c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012b30:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012b34:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
40012b38:	40 00 49 91 	call  4002517c <printf>                        <== NOT EXECUTED
40012b3c:	90 12 23 70 	or  %o0, 0x370, %o0	! 40036b70 <_CPU_Trap_slot_template+0x688><== NOT EXECUTED
            rc, strerror (rc));                                       
    rtems_rfs_fs_close (fs);                                          
40012b40:	40 00 38 76 	call  40020d18 <rtems_rfs_fs_close>            <== NOT EXECUTED
40012b44:	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",   
40012b48:	40 00 4d d7 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012b4c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40012b50:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012b54:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
            rc, strerror (rc));                                       
    return -1;                                                        
40012b58:	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",   
40012b5c:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012b60:	40 00 49 87 	call  4002517c <printf>                        <== NOT EXECUTED
40012b64:	90 12 20 e8 	or  %o0, 0xe8, %o0	! 40036ce8 <_CPU_Trap_slot_template+0x800><== NOT EXECUTED
40012b68:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012b6c:	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);                  
40012b70:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
40012b74:	92 10 20 01 	mov  1, %o1                                    
40012b78:	94 07 bf 54 	add  %fp, -172, %o2                            
40012b7c:	40 00 02 a3 	call  40013608 <rtems_rfs_inode_open>          
40012b80:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
40012b84:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012b88:	24 80 00 19 	ble,a   40012bec <rtems_rfs_format+0xd74>      <== ALWAYS TAKEN
40012b8c:	90 07 bf 54 	add  %fp, -172, %o0                            
  {                                                                   
    printf ("rtems-rfs: format: inode open failed: %d: %s\n",         
40012b90:	40 00 4d c5 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012b94:	01 00 00 00 	nop                                            <== NOT EXECUTED
40012b98:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012b9c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012ba0:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
40012ba4:	40 00 49 76 	call  4002517c <printf>                        <== NOT EXECUTED
40012ba8:	90 12 23 e0 	or  %o0, 0x3e0, %o0	! 40036be0 <_CPU_Trap_slot_template+0x6f8><== NOT EXECUTED
            rc, strerror (rc));                                       
    rtems_rfs_group_bitmap_free (fs, true, ino);                      
40012bac:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
40012bb0:	d4 07 bf 2c 	ld  [ %fp + -212 ], %o2                        <== NOT EXECUTED
40012bb4:	40 00 01 a7 	call  40013250 <rtems_rfs_group_bitmap_free>   <== NOT EXECUTED
40012bb8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
    rtems_rfs_fs_close (fs);                                          
40012bbc:	40 00 38 57 	call  40020d18 <rtems_rfs_fs_close>            <== NOT EXECUTED
40012bc0:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
40012bc4:	30 bf ff e1 	b,a   40012b48 <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",       
40012bc8:	40 00 4d b7 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012bcc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40012bd0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012bd4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012bd8:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
40012bdc:	40 00 49 68 	call  4002517c <printf>                        <== NOT EXECUTED
40012be0:	90 12 23 08 	or  %o0, 0x308, %o0	! 40036b08 <_CPU_Trap_slot_template+0x620><== NOT EXECUTED
40012be4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012be8:	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,                         
40012bec:	92 10 20 00 	clr  %o1                                       
40012bf0:	96 10 20 00 	clr  %o3                                       
40012bf4:	15 00 00 10 	sethi  %hi(0x4000), %o2                        
40012bf8:	98 10 20 00 	clr  %o4                                       
40012bfc:	40 00 03 7f 	call  400139f8 <rtems_rfs_inode_initialise>    
40012c00:	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)                                                         
40012c04:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012c08:	24 80 00 0a 	ble,a   40012c30 <rtems_rfs_format+0xdb8>      <== ALWAYS TAKEN
40012c0c:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
    printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",   
40012c10:	40 00 4d a5 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012c14:	01 00 00 00 	nop                                            <== NOT EXECUTED
40012c18:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012c1c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012c20:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012c24:	40 00 49 56 	call  4002517c <printf>                        <== NOT EXECUTED
40012c28:	90 12 20 10 	or  %o0, 0x10, %o0	! 40036c10 <_CPU_Trap_slot_template+0x728><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);             
40012c2c:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
40012c30:	d8 07 bf 2c 	ld  [ %fp + -212 ], %o4                        
40012c34:	92 07 bf 54 	add  %fp, -172, %o1                            
40012c38:	96 10 20 01 	mov  1, %o3                                    
40012c3c:	15 10 00 d3 	sethi  %hi(0x40034c00), %o2                    
40012c40:	40 00 2e 39 	call  4001e524 <rtems_rfs_dir_add_entry>       
40012c44:	94 12 a2 10 	or  %o2, 0x210, %o2	! 40034e10 <flashdisk_ops+0x1c>
  if (rc > 0)                                                         
40012c48:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012c4c:	24 80 00 0a 	ble,a   40012c74 <rtems_rfs_format+0xdfc>      <== ALWAYS TAKEN
40012c50:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
    printf ("rtems-rfs: format: directory add failed: %d: %s\n",      
40012c54:	40 00 4d 94 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012c58:	01 00 00 00 	nop                                            <== NOT EXECUTED
40012c5c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012c60:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012c64:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012c68:	40 00 49 45 	call  4002517c <printf>                        <== NOT EXECUTED
40012c6c:	90 12 20 48 	or  %o0, 0x48, %o0	! 40036c48 <_CPU_Trap_slot_template+0x760><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40012c70:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        <== NOT EXECUTED
40012c74:	40 00 02 dd 	call  400137e8 <rtems_rfs_inode_close>         
40012c78:	92 07 bf 54 	add  %fp, -172, %o1                            
  if (rc > 0)                                                         
40012c7c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012c80:	04 80 00 09 	ble  40012ca4 <rtems_rfs_format+0xe2c>         <== ALWAYS TAKEN
40012c84:	01 00 00 00 	nop                                            
    printf ("rtems-rfs: format: inode close failed: %d: %s\n",        
40012c88:	40 00 4d 87 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012c8c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40012c90:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012c94:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012c98:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012c9c:	40 00 49 38 	call  4002517c <printf>                        <== NOT EXECUTED
40012ca0:	90 12 20 80 	or  %o0, 0x80, %o0	! 40036c80 <_CPU_Trap_slot_template+0x798><== NOT EXECUTED
            rc, strerror (rc));                                       
                                                                      
  rc = rtems_rfs_fs_close (fs);                                       
40012ca4:	40 00 38 1d 	call  40020d18 <rtems_rfs_fs_close>            
40012ca8:	d0 07 bf 28 	ld  [ %fp + -216 ], %o0                        
  if (rc < 0)                                                         
40012cac:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40012cb0:	06 80 00 12 	bl  40012cf8 <rtems_rfs_format+0xe80>          <== NEVER TAKEN
40012cb4:	80 a7 60 00 	cmp  %i5, 0                                    
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_write_root_dir (name);                               
  if (rc > 0)                                                         
40012cb8:	12 bf ff a4 	bne  40012b48 <rtems_rfs_format+0xcd0>         <== NEVER TAKEN
40012cbc:	b0 10 20 00 	clr  %i0                                       
            rc, strerror (rc));                                       
    return -1;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40012cc0:	81 c7 e0 08 	ret                                            
40012cc4:	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));                                 
40012cc8:	40 00 43 9c 	call  40023b38 <__errno>                       <== NOT EXECUTED
40012ccc:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
40012cd0:	40 00 43 9a 	call  40023b38 <__errno>                       <== NOT EXECUTED
40012cd4:	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",   
40012cd8:	40 00 4d 73 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012cdc:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40012ce0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012ce4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012ce8:	11 10 00 da 	sethi  %hi(0x40036800), %o0                    <== NOT EXECUTED
40012cec:	40 00 49 24 	call  4002517c <printf>                        <== NOT EXECUTED
40012cf0:	90 12 23 38 	or  %o0, 0x338, %o0	! 40036b38 <_CPU_Trap_slot_template+0x650><== NOT EXECUTED
40012cf4:	30 bf ff f3 	b,a   40012cc0 <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));                                 
40012cf8:	40 00 43 90 	call  40023b38 <__errno>                       <== NOT EXECUTED
40012cfc:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
40012d00:	40 00 43 8e 	call  40023b38 <__errno>                       <== NOT EXECUTED
40012d04:	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",  
40012d08:	40 00 4d 67 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012d0c:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
40012d10:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40012d14:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012d18:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012d1c:	40 00 49 18 	call  4002517c <printf>                        <== NOT EXECUTED
40012d20:	90 12 20 b0 	or  %o0, 0xb0, %o0	! 40036cb0 <_CPU_Trap_slot_template+0x7c8><== NOT EXECUTED
40012d24:	30 bf ff e7 	b,a   40012cc0 <rtems_rfs_format+0xe48>        <== NOT EXECUTED
40012d28:	c2 07 bf 8c 	ld  [ %fp + -116 ], %g1                        <== NOT EXECUTED
40012d2c:	10 bf fc 7e 	b  40011f24 <rtems_rfs_format+0xac>            <== NOT EXECUTED
40012d30:	f8 00 60 20 	ld  [ %g1 + 0x20 ], %i4                        <== NOT EXECUTED
                                                                      

40020d18 <rtems_rfs_fs_close>: return 0; } int rtems_rfs_fs_close (rtems_rfs_file_system* fs) {
40020d18:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int group;                                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))                        
40020d1c:	90 10 20 00 	clr  %o0                                       
40020d20:	7f ff d0 e1 	call  400150a4 <rtems_rfs_trace>               
40020d24:	92 10 20 02 	mov  2, %o1                                    
40020d28:	80 8a 20 ff 	btst  0xff, %o0                                
40020d2c:	12 80 00 17 	bne  40020d88 <rtems_rfs_fs_close+0x70>        <== NEVER TAKEN
40020d30:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    
    printf ("rtems-rfs: close\n");                                    
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
40020d34:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
40020d38:	b8 10 20 00 	clr  %i4                                       
40020d3c:	80 a0 60 00 	cmp  %g1, 0                                    
40020d40:	04 80 00 0b 	ble  40020d6c <rtems_rfs_fs_close+0x54>        <== NEVER TAKEN
40020d44:	ba 10 20 00 	clr  %i5                                       
    rtems_rfs_group_close (fs, &fs->groups[group]);                   
40020d48:	d2 06 20 20 	ld  [ %i0 + 0x20 ], %o1                        
40020d4c:	90 10 00 18 	mov  %i0, %o0                                  
40020d50:	7f ff c8 86 	call  40012f68 <rtems_rfs_group_close>         
40020d54:	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++)                   
40020d58:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
40020d5c:	ba 07 60 01 	inc  %i5                                       
40020d60:	80 a0 40 1d 	cmp  %g1, %i5                                  
40020d64:	14 bf ff f9 	bg  40020d48 <rtems_rfs_fs_close+0x30>         <== NEVER TAKEN
40020d68:	b8 07 20 50 	add  %i4, 0x50, %i4                            
    rtems_rfs_group_close (fs, &fs->groups[group]);                   
                                                                      
  rtems_rfs_buffer_close (fs);                                        
40020d6c:	7f ff f4 61 	call  4001def0 <rtems_rfs_buffer_close>        
40020d70:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  free (fs);                                                          
40020d74:	90 10 00 18 	mov  %i0, %o0                                  
40020d78:	7f ff a0 ec 	call  40009128 <free>                          
40020d7c:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
40020d80:	81 c7 e0 08 	ret                                            
40020d84:	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");                                    
40020d88:	40 00 11 95 	call  400253dc <puts>                          <== NOT EXECUTED
40020d8c:	90 12 21 e0 	or  %o0, 0x1e0, %o0                            <== NOT EXECUTED
                                                                      
  for (group = 0; group < fs->group_count; group++)                   
40020d90:	10 bf ff ea 	b  40020d38 <rtems_rfs_fs_close+0x20>          <== NOT EXECUTED
40020d94:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        <== NOT EXECUTED
                                                                      

40020468 <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) {
40020468:	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))                         
4002046c:	90 10 20 00 	clr  %o0                                       
40020470:	7f ff d3 0d 	call  400150a4 <rtems_rfs_trace>               
40020474:	92 10 20 01 	mov  1, %o1                                    
40020478:	80 8a 20 ff 	btst  0xff, %o0                                
4002047c:	12 80 00 82 	bne  40020684 <rtems_rfs_fs_open+0x21c>        <== NEVER TAKEN
40020480:	92 10 00 18 	mov  %i0, %o1                                  
    printf ("rtems-rfs: open: %s\n", name);                           
                                                                      
  *fs = malloc (sizeof (rtems_rfs_file_system));                      
40020484:	7f ff a4 c6 	call  4000979c <malloc>                        
40020488:	90 10 20 84 	mov  0x84, %o0                                 
  if (!*fs)                                                           
4002048c:	80 a2 20 00 	cmp  %o0, 0                                    
40020490:	02 80 01 68 	be  40020a30 <rtems_rfs_fs_open+0x5c8>         <== NEVER TAKEN
40020494:	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));                    
40020498:	92 10 20 00 	clr  %o1                                       
4002049c:	40 00 12 ba 	call  40024f84 <memset>                        
400204a0:	94 10 20 84 	mov  0x84, %o2                                 
                                                                      
  (*fs)->user = user;                                                 
400204a4:	c2 07 00 00 	ld  [ %i4 ], %g1                               
#endif                                                                
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, *fs);                             
400204a8:	90 10 00 18 	mov  %i0, %o0                                  
    return -1;                                                        
  }                                                                   
                                                                      
  memset (*fs, 0, sizeof (rtems_rfs_file_system));                    
                                                                      
  (*fs)->user = user;                                                 
400204ac:	f2 20 60 80 	st  %i1, [ %g1 + 0x80 ]                        
  rtems_chain_initialize_empty (&(*fs)->buffers);                     
400204b0:	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;                                              
400204b4:	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 );                        
400204b8:	86 00 60 44 	add  %g1, 0x44, %g3                            
400204bc:	84 00 60 48 	add  %g1, 0x48, %g2                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
400204c0:	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;                                                  
400204c4:	c4 20 60 44 	st  %g2, [ %g1 + 0x44 ]                        
  rtems_chain_initialize_empty (&(*fs)->release);                     
400204c8:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  head->previous = NULL;                                              
400204cc:	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 );                        
400204d0:	86 00 60 54 	add  %g1, 0x54, %g3                            
400204d4:	84 00 60 58 	add  %g1, 0x58, %g2                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
400204d8:	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;                                                  
400204dc:	c4 20 60 54 	st  %g2, [ %g1 + 0x54 ]                        
  rtems_chain_initialize_empty (&(*fs)->release_modified);            
400204e0:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  head->previous = NULL;                                              
400204e4:	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 );                        
400204e8:	86 00 60 64 	add  %g1, 0x64, %g3                            
400204ec:	84 00 60 68 	add  %g1, 0x68, %g2                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
400204f0:	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;                                                  
400204f4:	c4 20 60 64 	st  %g2, [ %g1 + 0x64 ]                        
  rtems_chain_initialize_empty (&(*fs)->file_shares);                 
400204f8:	c2 07 00 00 	ld  [ %i4 ], %g1                               
  head->previous = NULL;                                              
400204fc:	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 );                        
40020500:	86 00 60 74 	add  %g1, 0x74, %g3                            
40020504:	84 00 60 78 	add  %g1, 0x78, %g2                            
                                                                      
  head->next = tail;                                                  
  head->previous = NULL;                                              
  tail->previous = head;                                              
40020508:	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;                                                  
4002050c:	c4 20 60 74 	st  %g2, [ %g1 + 0x74 ]                        
                                                                      
  (*fs)->max_held_buffers = max_held_buffers;                         
40020510:	d2 07 00 00 	ld  [ %i4 ], %o1                               
40020514:	f6 22 60 40 	st  %i3, [ %o1 + 0x40 ]                        
  (*fs)->buffers_count = 0;                                           
40020518:	c0 22 60 50 	clr  [ %o1 + 0x50 ]                            
  (*fs)->release_count = 0;                                           
4002051c:	c0 22 60 60 	clr  [ %o1 + 0x60 ]                            
  (*fs)->release_modified_count = 0;                                  
40020520:	c0 22 60 70 	clr  [ %o1 + 0x70 ]                            
#endif                                                                
                                                                      
  /*                                                                  
   * Open the buffer interface.                                       
   */                                                                 
  rc = rtems_rfs_buffer_open (name, *fs);                             
40020524:	7f ff f5 77 	call  4001db00 <rtems_rfs_buffer_open>         
40020528:	f4 22 40 00 	st  %i2, [ %o1 ]                               
  if (rc > 0)                                                         
4002052c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020530:	14 80 00 a9 	bg  400207d4 <rtems_rfs_fs_open+0x36c>         <== NEVER TAKEN
40020534:	94 10 20 00 	clr  %o2                                       
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
40020538:	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;                                              
4002053c:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            
  handle->bnum  = 0;                                                  
40020540:	c0 27 bf d0 	clr  [ %fp + -48 ]                             
  handle->buffer = NULL;                                              
40020544:	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);        
40020548:	90 10 00 1b 	mov  %i3, %o0                                  
4002054c:	92 07 bf cc 	add  %fp, -52, %o1                             
40020550:	7f ff f4 b4 	call  4001d820 <rtems_rfs_buffer_handle_request>
40020554:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
40020558:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4002055c:	04 80 00 1d 	ble  400205d0 <rtems_rfs_fs_open+0x168>        <== ALWAYS TAKEN
40020560:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
40020564:	7f ff d2 d0 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020568:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
4002056c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020570:	02 80 00 09 	be  40020594 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
40020574:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: request failed%d: %s\n",   
40020578:	40 00 17 4b 	call  400262a4 <strerror>                      <== NOT EXECUTED
4002057c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020580:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40020584:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40020588:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
4002058c:	40 00 12 fc 	call  4002517c <printf>                        <== NOT EXECUTED
40020590:	90 12 23 18 	or  %o0, 0x318, %o0	! 40038f18 <CSWTCH.2+0x1128><== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
40020594:	7f ff f6 57 	call  4001def0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
40020598:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
4002059c:	7f ff a2 e3 	call  40009128 <free>                          <== NOT EXECUTED
400205a0:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
400205a4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
400205a8:	7f ff d2 bf 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400205ac:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
400205b0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400205b4:	12 80 00 2c 	bne  40020664 <rtems_rfs_fs_open+0x1fc>        <== NOT EXECUTED
400205b8:	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;                                                       
400205bc:	40 00 0d 5f 	call  40023b38 <__errno>                       <== NOT EXECUTED
400205c0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
400205c4:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
400205c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400205cc:	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);                               
400205d0:	c2 07 bf d4 	ld  [ %fp + -44 ], %g1                         
400205d4:	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)      
400205d8:	c2 0f 60 02 	ldub  [ %i5 + 2 ], %g1                         
400205dc:	c4 0f 40 00 	ldub  [ %i5 ], %g2                             
400205e0:	c8 0f 60 01 	ldub  [ %i5 + 1 ], %g4                         
400205e4:	c6 0f 60 03 	ldub  [ %i5 + 3 ], %g3                         
400205e8:	83 28 60 08 	sll  %g1, 8, %g1                               
400205ec:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
400205f0:	89 29 20 10 	sll  %g4, 0x10, %g4                            
400205f4:	84 10 80 04 	or  %g2, %g4, %g2                              
400205f8:	84 10 80 03 	or  %g2, %g3, %g2                              
400205fc:	84 10 80 01 	or  %g2, %g1, %g2                              
40020600:	03 0a 02 48 	sethi  %hi(0x28092000), %g1                    
40020604:	82 10 60 01 	or  %g1, 1, %g1	! 28092001 <RAM_SIZE+0x27c92001>
40020608:	80 a0 80 01 	cmp  %g2, %g1                                  
4002060c:	22 80 00 29 	be,a   400206b0 <rtems_rfs_fs_open+0x248>      <== ALWAYS TAKEN
40020610:	c6 0f 60 0d 	ldub  [ %i5 + 0xd ], %g3                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
40020614:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020618:	7f ff d2 a3 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4002061c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40020620:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020624:	32 80 00 1c 	bne,a   40020694 <rtems_rfs_fs_open+0x22c>     <== NOT EXECUTED
40020628:	11 10 00 e3 	sethi  %hi(0x40038c00), %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);                       
4002062c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40020630:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
40020634:	7f ff f4 01 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40020638:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_fs_read_superblock (*fs);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
4002063c:	7f ff f6 2d 	call  4001def0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
40020640:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
40020644:	7f ff a2 b9 	call  40009128 <free>                          <== NOT EXECUTED
40020648:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4002064c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020650:	7f ff d2 95 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020654:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40020658:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4002065c:	02 bf ff d8 	be  400205bc <rtems_rfs_fs_open+0x154>         <== NOT EXECUTED
40020660:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: reading superblock: %d: %s\n",        
40020664:	40 00 17 10 	call  400262a4 <strerror>                      <== NOT EXECUTED
40020668:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4002066c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40020670:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40020674:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40020678:	40 00 12 c1 	call  4002517c <printf>                        <== NOT EXECUTED
4002067c:	90 12 21 20 	or  %o0, 0x120, %o0	! 40039120 <CSWTCH.2+0x1330><== NOT EXECUTED
40020680:	30 bf ff cf 	b,a   400205bc <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);                           
40020684:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
40020688:	40 00 12 bd 	call  4002517c <printf>                        <== NOT EXECUTED
4002068c:	90 12 22 a0 	or  %o0, 0x2a0, %o0	! 40038ea0 <CSWTCH.2+0x10b0><== NOT EXECUTED
40020690:	30 bf ff 7d 	b,a   40020484 <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");
40020694:	40 00 13 52 	call  400253dc <puts>                          <== NOT EXECUTED
40020698:	90 12 23 50 	or  %o0, 0x350, %o0                            <== NOT EXECUTED
4002069c:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
400206a0:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
400206a4:	7f ff f3 e5 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400206a8:	ba 10 20 05 	mov  5, %i5                                    <== NOT EXECUTED
400206ac:	30 bf ff e4 	b,a   4002063c <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);              
400206b0:	c2 0f 60 0e 	ldub  [ %i5 + 0xe ], %g1                       
400206b4:	c4 0f 60 0f 	ldub  [ %i5 + 0xf ], %g2                       
400206b8:	d6 0f 60 0c 	ldub  [ %i5 + 0xc ], %o3                       
400206bc:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
400206c0:	83 28 60 08 	sll  %g1, 8, %g1                               
400206c4:	97 2a e0 18 	sll  %o3, 0x18, %o3                            
400206c8:	96 12 c0 03 	or  %o3, %g3, %o3                              
400206cc:	96 12 c0 02 	or  %o3, %g2, %o3                              
400206d0:	96 12 c0 01 	or  %o3, %g1, %o3                              
400206d4:	d6 26 e0 04 	st  %o3, [ %i3 + 4 ]                           
  fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);          
400206d8:	c6 0f 60 09 	ldub  [ %i5 + 9 ], %g3                         
400206dc:	c2 0f 60 0a 	ldub  [ %i5 + 0xa ], %g1                       
400206e0:	c4 0f 60 0b 	ldub  [ %i5 + 0xb ], %g2                       
400206e4:	f4 0f 60 08 	ldub  [ %i5 + 8 ], %i2                         
400206e8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
400206ec:	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);  
400206f0:	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;                                         
400206f4:	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);          
400206f8:	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;                                         
400206fc:	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);          
40020700:	b4 16 80 03 	or  %i2, %g3, %i2                              
40020704:	b4 16 80 02 	or  %i2, %g2, %i2                              
40020708:	b4 16 80 01 	or  %i2, %g1, %i2                              
4002070c:	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;                                         
40020710:	40 00 44 dd 	call  40031a84 <__muldi3>                      
40020714:	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;                             
40020718:	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;                                         
4002071c:	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;                             
40020720:	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;                                         
40020724:	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;                             
40020728:	94 10 20 00 	clr  %o2                                       
4002072c:	40 00 44 d6 	call  40031a84 <__muldi3>                      
40020730:	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))           
40020734:	80 a6 00 08 	cmp  %i0, %o0                                  
40020738:	38 80 00 3a 	bgu,a   40020820 <rtems_rfs_fs_open+0x3b8>     <== NEVER TAKEN
4002073c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020740:	02 80 00 35 	be  40020814 <rtems_rfs_fs_open+0x3ac>         <== ALWAYS TAKEN
40020744:	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)
40020748:	c2 0f 60 24 	ldub  [ %i5 + 0x24 ], %g1                      <== NOT EXECUTED
4002074c:	c8 0f 60 25 	ldub  [ %i5 + 0x25 ], %g4                      
40020750:	c6 0f 60 27 	ldub  [ %i5 + 0x27 ], %g3                      
40020754:	c4 0f 60 26 	ldub  [ %i5 + 0x26 ], %g2                      
40020758:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4002075c:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40020760:	85 28 a0 08 	sll  %g2, 8, %g2                               
40020764:	82 10 40 04 	or  %g1, %g4, %g1                              
40020768:	82 10 40 03 	or  %g1, %g3, %g1                              
4002076c:	82 10 40 02 	or  %g1, %g2, %g1                              
40020770:	80 a0 60 38 	cmp  %g1, 0x38                                 
40020774:	22 80 00 35 	be,a   40020848 <rtems_rfs_fs_open+0x3e0>      <== ALWAYS TAKEN
40020778:	c6 0f 60 13 	ldub  [ %i5 + 0x13 ], %g3                      
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4002077c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020780:	7f ff d2 49 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020784:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40020788:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4002078c:	22 bf ff a9 	be,a   40020630 <rtems_rfs_fs_open+0x1c8>      <== NOT EXECUTED
40020790:	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);
40020794:	c6 0f 60 05 	ldub  [ %i5 + 5 ], %g3                         <== NOT EXECUTED
40020798:	c2 0f 60 06 	ldub  [ %i5 + 6 ], %g1                         <== NOT EXECUTED
4002079c:	d2 0f 60 04 	ldub  [ %i5 + 4 ], %o1                         <== NOT EXECUTED
400207a0:	c4 0f 60 07 	ldub  [ %i5 + 7 ], %g2                         <== NOT EXECUTED
400207a4:	87 28 e0 10 	sll  %g3, 0x10, %g3                            <== NOT EXECUTED
400207a8:	83 28 60 08 	sll  %g1, 8, %g1                               <== NOT EXECUTED
400207ac:	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",
400207b0:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
400207b4:	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",
400207b8:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
              read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
400207bc:	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",
400207c0:	90 12 23 d0 	or  %o0, 0x3d0, %o0                            <== NOT EXECUTED
400207c4:	40 00 12 6e 	call  4002517c <printf>                        <== NOT EXECUTED
400207c8:	92 12 40 01 	or  %o1, %g1, %o1                              <== NOT EXECUTED
400207cc:	10 bf ff 99 	b  40020630 <rtems_rfs_fs_open+0x1c8>          <== NOT EXECUTED
400207d0:	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);                                                       
400207d4:	7f ff a2 55 	call  40009128 <free>                          <== NOT EXECUTED
400207d8:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
400207dc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
400207e0:	7f ff d2 31 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400207e4:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
400207e8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400207ec:	02 bf ff 74 	be  400205bc <rtems_rfs_fs_open+0x154>         <== NOT EXECUTED
400207f0:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: buffer open failed: %d: %s\n",        
400207f4:	40 00 16 ac 	call  400262a4 <strerror>                      <== NOT EXECUTED
400207f8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400207fc:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40020800:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40020804:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
40020808:	40 00 12 5d 	call  4002517c <printf>                        <== NOT EXECUTED
4002080c:	90 12 22 e8 	or  %o0, 0x2e8, %o0	! 40038ee8 <CSWTCH.2+0x10f8><== NOT EXECUTED
40020810:	30 bf ff 6b 	b,a   400205bc <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))           
40020814:	28 bf ff ce 	bleu,a   4002074c <rtems_rfs_fs_open+0x2e4>    <== ALWAYS TAKEN
40020818:	c2 0f 60 24 	ldub  [ %i5 + 0x24 ], %g1                      
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
4002081c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020820:	7f ff d2 21 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020824:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40020828:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4002082c:	22 bf ff 81 	be,a   40020630 <rtems_rfs_fs_open+0x1c8>      <== NOT EXECUTED
40020830:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
40020834:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
40020838:	40 00 12 e9 	call  400253dc <puts>                          <== NOT EXECUTED
4002083c:	90 12 23 90 	or  %o0, 0x390, %o0	! 40038f90 <CSWTCH.2+0x11a0><== NOT EXECUTED
40020840:	10 bf ff 7c 	b  40020630 <rtems_rfs_fs_open+0x1c8>          <== NOT EXECUTED
40020844:	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);     
40020848:	c2 0f 60 10 	ldub  [ %i5 + 0x10 ], %g1                      
4002084c:	c8 0f 60 11 	ldub  [ %i5 + 0x11 ], %g4                      
40020850:	c4 0f 60 12 	ldub  [ %i5 + 0x12 ], %g2                      
40020854:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40020858:	85 28 a0 08 	sll  %g2, 8, %g2                               
4002085c:	83 28 60 18 	sll  %g1, 0x18, %g1                            
40020860:	82 10 40 04 	or  %g1, %g4, %g1                              
40020864:	82 10 40 03 	or  %g1, %g3, %g1                              
40020868:	82 10 40 02 	or  %g1, %g2, %g1                              
4002086c:	c2 26 e0 18 	st  %g1, [ %i3 + 0x18 ]                        
  fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
40020870:	c6 0f 60 17 	ldub  [ %i5 + 0x17 ], %g3                      
40020874:	c2 0f 60 14 	ldub  [ %i5 + 0x14 ], %g1                      
40020878:	c8 0f 60 15 	ldub  [ %i5 + 0x15 ], %g4                      
4002087c:	c4 0f 60 16 	ldub  [ %i5 + 0x16 ], %g2                      
40020880:	89 29 20 10 	sll  %g4, 0x10, %g4                            
40020884:	85 28 a0 08 	sll  %g2, 8, %g2                               
40020888:	83 28 60 18 	sll  %g1, 0x18, %g1                            
4002088c:	82 10 40 04 	or  %g1, %g4, %g1                              
40020890:	82 10 40 03 	or  %g1, %g3, %g1                              
40020894:	82 10 40 02 	or  %g1, %g2, %g1                              
40020898:	c2 26 e0 1c 	st  %g1, [ %i3 + 0x1c ]                        
  fs->group_count     = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);         
4002089c:	c6 0f 60 19 	ldub  [ %i5 + 0x19 ], %g3                      
400208a0:	c2 0f 60 1a 	ldub  [ %i5 + 0x1a ], %g1                      
400208a4:	c4 0f 60 1b 	ldub  [ %i5 + 0x1b ], %g2                      
400208a8:	f0 0f 60 18 	ldub  [ %i5 + 0x18 ], %i0                      
400208ac:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
400208b0:	83 28 60 08 	sll  %g1, 8, %g1                               
400208b4:	b1 2e 20 18 	sll  %i0, 0x18, %i0                            
400208b8:	b0 16 00 03 	or  %i0, %g3, %i0                              
400208bc:	b0 16 00 02 	or  %i0, %g2, %i0                              
400208c0:	b0 16 00 01 	or  %i0, %g1, %i0                              
400208c4:	f0 26 e0 24 	st  %i0, [ %i3 + 0x24 ]                        
  fs->group_blocks    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);   
400208c8:	c4 0f 60 1f 	ldub  [ %i5 + 0x1f ], %g2                      
400208cc:	f2 0f 60 1c 	ldub  [ %i5 + 0x1c ], %i1                      
400208d0:	c6 0f 60 1d 	ldub  [ %i5 + 0x1d ], %g3                      
400208d4:	c2 0f 60 1e 	ldub  [ %i5 + 0x1e ], %g1                      
400208d8:	87 28 e0 10 	sll  %g3, 0x10, %g3                            
400208dc:	83 28 60 08 	sll  %g1, 8, %g1                               
400208e0:	b3 2e 60 18 	sll  %i1, 0x18, %i1                            
400208e4:	b2 16 40 03 	or  %i1, %g3, %i1                              
400208e8:	b2 16 40 02 	or  %i1, %g2, %i1                              
400208ec:	b2 16 40 01 	or  %i1, %g1, %i1                              
400208f0:	f2 26 e0 28 	st  %i1, [ %i3 + 0x28 ]                        
  fs->group_inodes    = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);   
400208f4:	c4 0f 60 21 	ldub  [ %i5 + 0x21 ], %g2                      
400208f8:	de 0f 60 20 	ldub  [ %i5 + 0x20 ], %o7                      
400208fc:	c6 0f 60 22 	ldub  [ %i5 + 0x22 ], %g3                      
40020900:	c8 0f 60 23 	ldub  [ %i5 + 0x23 ], %g4                      
40020904:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
                                                                      
  fs->blocks_per_block =                                              
    rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);    
40020908:	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);   
4002090c:	bb 2b e0 18 	sll  %o7, 0x18, %i5                            
40020910:	87 28 e0 08 	sll  %g3, 8, %g3                               
40020914:	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;                    
40020918:	85 28 60 02 	sll  %g1, 2, %g2                               
4002091c:	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);   
40020920:	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;
40020924:	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);   
40020928:	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 =                                       
4002092c:	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;
40020930:	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 =                                              
40020934:	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;
40020938:	7f ff 87 20 	call  400025b8 <.umul>                         
4002093c:	fa 26 e0 2c 	st  %i5, [ %i3 + 0x2c ]                        
40020940:	83 2a 20 02 	sll  %o0, 2, %g1                               
40020944:	82 00 40 08 	add  %g1, %o0, %g1                             
                                                                      
  fs->inodes = fs->group_count * fs->group_inodes;                    
40020948:	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 =                                       
4002094c:	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;                    
40020950:	7f ff 87 1a 	call  400025b8 <.umul>                         
40020954:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
40020958:	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;                    
4002095c:	d0 26 e0 14 	st  %o0, [ %i3 + 0x14 ]                        
                                                                      
  fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;       
40020960:	7f ff 87 50 	call  400026a0 <.udiv>                         
40020964:	90 10 00 1a 	mov  %i2, %o0                                  
40020968:	d0 26 e0 30 	st  %o0, [ %i3 + 0x30 ]                        
                                                                      
  if (fs->group_blocks >                                              
      rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))     
4002096c:	b5 2e a0 03 	sll  %i2, 3, %i2                               
40020970:	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 >                                              
40020974:	80 a6 40 1a 	cmp  %i1, %i2                                  
40020978:	08 80 00 10 	bleu  400209b8 <rtems_rfs_fs_open+0x550>       <== ALWAYS TAKEN
4002097c:	90 10 00 1b 	mov  %i3, %o0                                  
40020980:	7f ff f3 2e 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40020984:	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))                       
40020988:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4002098c:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
  handle->dirty = false;                                              
40020990:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40020994:	c0 27 bf d0 	clr  [ %fp + -48 ]                             <== NOT EXECUTED
40020998:	7f ff d1 c3 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4002099c:	c0 27 bf d4 	clr  [ %fp + -44 ]                             <== NOT EXECUTED
400209a0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400209a4:	02 bf fe fc 	be  40020594 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
400209a8:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
400209ac:	40 00 12 8c 	call  400253dc <puts>                          <== NOT EXECUTED
400209b0:	90 12 20 18 	or  %o0, 0x18, %o0	! 40039018 <CSWTCH.2+0x1228><== NOT EXECUTED
400209b4:	30 bf fe f8 	b,a   40020594 <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);                       
400209b8:	7f ff f3 20 	call  4001d638 <rtems_rfs_buffer_handle_release>
400209bc:	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));
400209c0:	d2 06 e0 08 	ld  [ %i3 + 8 ], %o1                           
  handle->dirty = false;                                              
400209c4:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            
  handle->bnum  = 0;                                                  
400209c8:	c0 27 bf d0 	clr  [ %fp + -48 ]                             
  handle->buffer = NULL;                                              
400209cc:	c0 27 bf d4 	clr  [ %fp + -44 ]                             
400209d0:	7f ff f4 ff 	call  4001ddcc <rtems_rfs_buffer_setblksize>   
400209d4:	90 10 00 1b 	mov  %i3, %o0                                  
  if (rc > 0)                                                         
400209d8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400209dc:	04 80 00 23 	ble  40020a68 <rtems_rfs_fs_open+0x600>        <== ALWAYS TAKEN
400209e0:	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);                       
400209e4:	7f ff f3 15 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400209e8:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  {                                                                   
    rtems_rfs_buffer_handle_close (fs, &handle);                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
400209ec:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
400209f0:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
  handle->dirty = false;                                              
400209f4:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400209f8:	c0 27 bf d0 	clr  [ %fp + -48 ]                             <== NOT EXECUTED
400209fc:	7f ff d1 aa 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020a00:	c0 27 bf d4 	clr  [ %fp + -44 ]                             <== NOT EXECUTED
40020a04:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020a08:	02 bf fe e3 	be  40020594 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
40020a0c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
40020a10:	40 00 16 25 	call  400262a4 <strerror>                      <== NOT EXECUTED
40020a14:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020a18:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40020a1c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40020a20:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40020a24:	40 00 11 d6 	call  4002517c <printf>                        <== NOT EXECUTED
40020a28:	90 12 20 60 	or  %o0, 0x60, %o0	! 40039060 <CSWTCH.2+0x1270><== NOT EXECUTED
40020a2c:	30 bf fe da 	b,a   40020594 <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))                       
40020a30:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020a34:	7f ff d1 9c 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020a38:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40020a3c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020a40:	02 80 00 04 	be  40020a50 <rtems_rfs_fs_open+0x5e8>         <== NOT EXECUTED
40020a44:	11 10 00 e3 	sethi  %hi(0x40038c00), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: open: no memory for file system data\n");   
40020a48:	40 00 12 65 	call  400253dc <puts>                          <== NOT EXECUTED
40020a4c:	90 12 22 b8 	or  %o0, 0x2b8, %o0	! 40038eb8 <CSWTCH.2+0x10c8><== NOT EXECUTED
    errno = ENOMEM;                                                   
40020a50:	40 00 0c 3a 	call  40023b38 <__errno>                       <== NOT EXECUTED
40020a54:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40020a58:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
40020a5c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40020a60:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020a64:	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));    
40020a68:	fa 06 e0 24 	ld  [ %i3 + 0x24 ], %i5                        
40020a6c:	92 10 20 50 	mov  0x50, %o1                                 
40020a70:	7f ff a1 4b 	call  40008f9c <calloc>                        
40020a74:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  if (!fs->groups)                                                    
40020a78:	80 a2 20 00 	cmp  %o0, 0                                    
40020a7c:	02 80 00 97 	be  40020cd8 <rtems_rfs_fs_open+0x870>         <== NEVER TAKEN
40020a80:	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++)                   
40020a84:	b2 10 20 00 	clr  %i1                                       
40020a88:	80 a7 60 00 	cmp  %i5, 0                                    
40020a8c:	14 80 00 08 	bg  40020aac <rtems_rfs_fs_open+0x644>         <== ALWAYS TAKEN
40020a90:	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);  
40020a94:	10 80 00 35 	b  40020b68 <rtems_rfs_fs_open+0x700>          <== NOT EXECUTED
40020a98:	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++)                   
40020a9c:	b4 06 a0 01 	inc  %i2                                       
40020aa0:	80 a6 80 01 	cmp  %i2, %g1                                  
40020aa4:	16 80 00 30 	bge  40020b64 <rtems_rfs_fs_open+0x6fc>        <== ALWAYS TAKEN
40020aa8:	b2 06 60 50 	add  %i1, 0x50, %i1                            
  {                                                                   
    rc = rtems_rfs_group_open (fs,                                    
                               rtems_rfs_fs_block (fs, group, 0),     
40020aac:	fa 06 e0 28 	ld  [ %i3 + 0x28 ], %i5                        
40020ab0:	90 10 00 1a 	mov  %i2, %o0                                  
40020ab4:	7f ff 86 c1 	call  400025b8 <.umul>                         
40020ab8:	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,                                    
40020abc:	d8 06 e0 20 	ld  [ %i3 + 0x20 ], %o4                        
40020ac0:	d6 06 e0 2c 	ld  [ %i3 + 0x2c ], %o3                        
                               rtems_rfs_fs_block (fs, group, 0),     
40020ac4:	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,                                    
40020ac8:	94 10 00 1d 	mov  %i5, %o2                                  
40020acc:	98 03 00 19 	add  %o4, %i1, %o4                             
40020ad0:	7f ff c8 99 	call  40012d34 <rtems_rfs_group_open>          
40020ad4:	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)                                                       
40020ad8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020adc:	24 bf ff f0 	ble,a   40020a9c <rtems_rfs_fs_open+0x634>     <== ALWAYS TAKEN
40020ae0:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
    {                                                                 
      int g;                                                          
      for (g = 0; g < group; g++)                                     
40020ae4:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
40020ae8:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
40020aec:	02 80 00 0a 	be  40020b14 <rtems_rfs_fs_open+0x6ac>         <== NOT EXECUTED
40020af0:	b2 10 20 00 	clr  %i1                                       <== NOT EXECUTED
        rtems_rfs_group_close (fs, &fs->groups[g]);                   
40020af4:	d2 06 e0 20 	ld  [ %i3 + 0x20 ], %o1                        <== NOT EXECUTED
40020af8:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40020afc:	7f ff c9 1b 	call  40012f68 <rtems_rfs_group_close>         <== NOT EXECUTED
40020b00:	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++)                                     
40020b04:	b2 06 60 01 	inc  %i1                                       <== NOT EXECUTED
40020b08:	80 a6 40 1a 	cmp  %i1, %i2                                  <== NOT EXECUTED
40020b0c:	12 bf ff fa 	bne  40020af4 <rtems_rfs_fs_open+0x68c>        <== NOT EXECUTED
40020b10:	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);                       
40020b14:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
40020b18:	7f ff f2 c8 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40020b1c:	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))                     
40020b20:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020b24:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
  handle->dirty = false;                                              
40020b28:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40020b2c:	c0 27 bf d0 	clr  [ %fp + -48 ]                             <== NOT EXECUTED
40020b30:	7f ff d1 5d 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020b34:	c0 27 bf d4 	clr  [ %fp + -44 ]                             <== NOT EXECUTED
40020b38:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020b3c:	02 bf fe 96 	be  40020594 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
40020b40:	01 00 00 00 	nop                                            <== NOT EXECUTED
        printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
40020b44:	40 00 15 d8 	call  400262a4 <strerror>                      <== NOT EXECUTED
40020b48:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020b4c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40020b50:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40020b54:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40020b58:	40 00 11 89 	call  4002517c <printf>                        <== NOT EXECUTED
40020b5c:	90 12 20 e0 	or  %o0, 0xe0, %o0	! 400390e0 <CSWTCH.2+0x12f0><== NOT EXECUTED
40020b60:	30 bf fe 8d 	b,a   40020594 <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);  
40020b64:	d0 07 00 00 	ld  [ %i4 ], %o0                               
40020b68:	92 10 20 01 	mov  1, %o1                                    
40020b6c:	94 07 bf d8 	add  %fp, -40, %o2                             
40020b70:	7f ff ca a6 	call  40013608 <rtems_rfs_inode_open>          
40020b74:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
40020b78:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020b7c:	14 80 00 45 	bg  40020c90 <rtems_rfs_fs_open+0x828>         <== NEVER TAKEN
40020b80:	01 00 00 00 	nop                                            
              rc, strerror (rc));                                     
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)                  
40020b84:	d0 07 00 00 	ld  [ %i4 ], %o0                               
40020b88:	c2 02 00 00 	ld  [ %o0 ], %g1                               
40020b8c:	80 88 60 04 	btst  4, %g1                                   
40020b90:	12 80 00 10 	bne  40020bd0 <rtems_rfs_fs_open+0x768>        
40020b94:	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);                    
40020b98:	c4 08 60 03 	ldub  [ %g1 + 3 ], %g2                         
40020b9c:	c6 08 60 02 	ldub  [ %g1 + 2 ], %g3                         
40020ba0:	83 28 e0 08 	sll  %g3, 8, %g1                               
40020ba4:	82 10 40 02 	or  %g1, %g2, %g1                              
  {                                                                   
    mode = rtems_rfs_inode_get_mode (&inode);                         
                                                                      
    if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))                
40020ba8:	05 3f ff c0 	sethi  %hi(0xffff0000), %g2                    
40020bac:	87 28 60 10 	sll  %g1, 0x10, %g3                            
40020bb0:	80 a0 c0 02 	cmp  %g3, %g2                                  
40020bb4:	02 80 00 23 	be  40020c40 <rtems_rfs_fs_open+0x7d8>         <== NEVER TAKEN
40020bb8:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
40020bbc:	82 08 40 02 	and  %g1, %g2, %g1                             
40020bc0:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
40020bc4:	80 a0 40 02 	cmp  %g1, %g2                                  
40020bc8:	12 80 00 1e 	bne  40020c40 <rtems_rfs_fs_open+0x7d8>        <== NEVER TAKEN
40020bcc:	01 00 00 00 	nop                                            
      errno = EIO;                                                    
      return -1;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (*fs, &inode);                           
40020bd0:	7f ff cb 06 	call  400137e8 <rtems_rfs_inode_close>         
40020bd4:	92 07 bf d8 	add  %fp, -40, %o1                             
  if (rc > 0)                                                         
40020bd8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020bdc:	14 80 00 07 	bg  40020bf8 <rtems_rfs_fs_open+0x790>         <== NEVER TAKEN
40020be0:	01 00 00 00 	nop                                            
      printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
    errno = rc;                                                       
    return -1;                                                        
  }                                                                   
                                                                      
  errno = 0;                                                          
40020be4:	40 00 0b d5 	call  40023b38 <__errno>                       
40020be8:	b0 10 20 00 	clr  %i0	! 0 <PROM_START>                      
40020bec:	c0 22 00 00 	clr  [ %o0 ]                                   
40020bf0:	81 c7 e0 08 	ret                                            
40020bf4:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (*fs, &inode);                           
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_buffer_close (*fs);                                     
40020bf8:	7f ff f4 be 	call  4001def0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
40020bfc:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
40020c00:	7f ff a1 4a 	call  40009128 <free>                          <== NOT EXECUTED
40020c04:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
40020c08:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020c0c:	7f ff d1 26 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020c10:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40020c14:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020c18:	02 bf fe 69 	be  400205bc <rtems_rfs_fs_open+0x154>         <== NOT EXECUTED
40020c1c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
40020c20:	40 00 15 a1 	call  400262a4 <strerror>                      <== NOT EXECUTED
40020c24:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020c28:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40020c2c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40020c30:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40020c34:	40 00 11 52 	call  4002517c <printf>                        <== NOT EXECUTED
40020c38:	90 12 21 b0 	or  %o0, 0x1b0, %o0	! 400391b0 <CSWTCH.2+0x13c0><== NOT EXECUTED
40020c3c:	30 bf fe 60 	b,a   400205bc <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);                            
40020c40:	7f ff ca ea 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020c44:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
      rtems_rfs_buffer_close (*fs);                                   
40020c48:	7f ff f4 aa 	call  4001def0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
40020c4c:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
      free (*fs);                                                     
40020c50:	7f ff a1 36 	call  40009128 <free>                          <== NOT EXECUTED
40020c54:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                     
40020c58:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020c5c:	7f ff d1 12 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020c60:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40020c64:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020c68:	02 80 00 04 	be  40020c78 <rtems_rfs_fs_open+0x810>         <== NOT EXECUTED
40020c6c:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
        printf ("rtems-rfs: open: invalid root inode mode\n");        
40020c70:	40 00 11 db 	call  400253dc <puts>                          <== NOT EXECUTED
40020c74:	90 12 21 80 	or  %o0, 0x180, %o0	! 40039180 <CSWTCH.2+0x1390><== NOT EXECUTED
      errno = EIO;                                                    
40020c78:	40 00 0b b0 	call  40023b38 <__errno>                       <== NOT EXECUTED
40020c7c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40020c80:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40020c84:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40020c88:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020c8c:	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);                                     
40020c90:	7f ff f4 98 	call  4001def0 <rtems_rfs_buffer_close>        <== NOT EXECUTED
40020c94:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    free (*fs);                                                       
40020c98:	7f ff a1 24 	call  40009128 <free>                          <== NOT EXECUTED
40020c9c:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))                       
40020ca0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020ca4:	7f ff d1 00 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020ca8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
40020cac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020cb0:	02 bf fe 43 	be  400205bc <rtems_rfs_fs_open+0x154>         <== NOT EXECUTED
40020cb4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: open: reading root inode: %d: %s\n",        
40020cb8:	40 00 15 7b 	call  400262a4 <strerror>                      <== NOT EXECUTED
40020cbc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40020cc0:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40020cc4:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40020cc8:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40020ccc:	40 00 11 2c 	call  4002517c <printf>                        <== NOT EXECUTED
40020cd0:	90 12 21 50 	or  %o0, 0x150, %o0	! 40039150 <CSWTCH.2+0x1360><== NOT EXECUTED
40020cd4:	30 bf fe 3a 	b,a   400205bc <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);                       
40020cd8:	92 07 bf cc 	add  %fp, -52, %o1                             <== NOT EXECUTED
40020cdc:	7f ff f2 57 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40020ce0:	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))                       
40020ce4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020ce8:	92 10 20 01 	mov  1, %o1                                    <== NOT EXECUTED
  handle->dirty = false;                                              
40020cec:	c0 2f bf cc 	clrb  [ %fp + -52 ]                            <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40020cf0:	c0 27 bf d0 	clr  [ %fp + -48 ]                             <== NOT EXECUTED
  handle->buffer = NULL;                                              
40020cf4:	c0 27 bf d4 	clr  [ %fp + -44 ]                             <== NOT EXECUTED
40020cf8:	7f ff d0 eb 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020cfc:	ba 10 20 0c 	mov  0xc, %i5                                  <== NOT EXECUTED
40020d00:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020d04:	02 bf fe 24 	be  40020594 <rtems_rfs_fs_open+0x12c>         <== NOT EXECUTED
40020d08:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
      printf ("rtems-rfs: read-superblock: no memory for group table\n");
40020d0c:	40 00 11 b4 	call  400253dc <puts>                          <== NOT EXECUTED
40020d10:	90 12 20 a8 	or  %o0, 0xa8, %o0	! 400390a8 <CSWTCH.2+0x12b8><== NOT EXECUTED
40020d14:	30 bf fe 20 	b,a   40020594 <rtems_rfs_fs_open+0x12c>       <== NOT EXECUTED
                                                                      

4002041c <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) {
4002041c:	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;                                         
40020420:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           <== NOT EXECUTED
40020424:	d6 06 20 04 	ld  [ %i0 + 4 ], %o3                           <== NOT EXECUTED
40020428:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4002042c:	40 00 45 96 	call  40031a84 <__muldi3>                      <== NOT EXECUTED
40020430:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
}                                                                     
40020434:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
40020438:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4002043c:	93 e8 00 09 	restore  %g0, %o1, %o1                         <== NOT EXECUTED
                                                                      

40013014 <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) {
40013014:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_bitmap_bit bit;                                           
  int                  offset;                                        
  bool                 updown;                                        
  int                  direction;                                     
                                                                      
  if (inode)                                                          
40013018:	80 a6 a0 00 	cmp  %i2, 0                                    
4001301c:	22 80 00 04 	be,a   4001302c <rtems_rfs_group_bitmap_alloc+0x18>
40013020:	e6 06 20 28 	ld  [ %i0 + 0x28 ], %l3                        
  {                                                                   
    size = fs->group_inodes;                                          
40013024:	e6 06 20 2c 	ld  [ %i0 + 0x2c ], %l3                        
    goal -= RTEMS_RFS_ROOT_INO;                                       
40013028:	b2 06 7f ff 	add  %i1, -1, %i1                              
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
4001302c:	90 10 00 19 	mov  %i1, %o0                                  
40013030:	7f ff bd 9c 	call  400026a0 <.udiv>                         
40013034:	92 10 00 13 	mov  %l3, %o1                                  
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
40013038:	92 10 00 13 	mov  %l3, %o1                                  
    goal -= RTEMS_RFS_ROOT_INO;                                       
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
4001303c:	a2 10 00 08 	mov  %o0, %l1                                  
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
  offset = 0;                                                         
  updown = true;                                                      
  direction = 1;                                                      
40013040:	b8 10 20 01 	mov  1, %i4                                    
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
40013044:	90 10 00 19 	mov  %i1, %o0                                  
40013048:	40 00 79 e3 	call  400317d4 <.urem>                         
4001304c:	ba 10 00 11 	mov  %l1, %i5                                  
  offset = 0;                                                         
  updown = true;                                                      
40013050:	a0 10 20 01 	mov  1, %l0                                    
  }                                                                   
  else                                                                
    size = fs->group_blocks;                                          
                                                                      
  group_start = goal / size;                                          
  bit = (rtems_rfs_bitmap_bit) (goal % size);                         
40013054:	d0 27 bf fc 	st  %o0, [ %fp + -4 ]                          
   */                                                                 
  while (true)                                                        
  {                                                                   
    rtems_rfs_bitmap_control* bitmap;                                 
    int                       group;                                  
    bool                      allocated = false;                      
40013058:	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;                                                         
4001305c:	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))                    
40013060:	80 a7 60 00 	cmp  %i5, 0                                    
40013064:	06 80 00 32 	bl  4001312c <rtems_rfs_group_bitmap_alloc+0x118><== NEVER TAKEN
40013068:	80 8c 20 ff 	btst  0xff, %l0                                
4001306c:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
40013070:	80 a0 40 1d 	cmp  %g1, %i5                                  
40013074:	04 80 00 2e 	ble  4001312c <rtems_rfs_group_bitmap_alloc+0x118>
40013078:	80 8c 20 ff 	btst  0xff, %l0                                
      updown = false;                                                 
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
      bitmap = &fs->groups[group].inode_bitmap;                       
4001307c:	e4 06 20 20 	ld  [ %i0 + 0x20 ], %l2                        
40013080:	ab 2f 60 04 	sll  %i5, 4, %l5                               
40013084:	a9 2f 60 06 	sll  %i5, 6, %l4                               
      direction = direction > 0 ? -1 : 1;                             
      updown = false;                                                 
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
40013088:	80 a6 a0 00 	cmp  %i2, 0                                    
      bitmap = &fs->groups[group].inode_bitmap;                       
4001308c:	82 05 40 14 	add  %l5, %l4, %g1                             
      direction = direction > 0 ? -1 : 1;                             
      updown = false;                                                 
      continue;                                                       
    }                                                                 
                                                                      
   if (inode)                                                         
40013090:	02 80 00 46 	be  400131a8 <rtems_rfs_group_bitmap_alloc+0x194>
40013094:	a4 04 80 01 	add  %l2, %g1, %l2                             
      bitmap = &fs->groups[group].inode_bitmap;                       
40013098:	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);  
4001309c:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
400130a0:	90 10 00 12 	mov  %l2, %o0                                  
400130a4:	94 07 bf fb 	add  %fp, -5, %o2                              
400130a8:	40 00 24 54 	call  4001c1f8 <rtems_rfs_bitmap_map_alloc>    
400130ac:	96 07 bf fc 	add  %fp, -4, %o3                              
    if (rc > 0)                                                       
400130b0:	80 a2 20 00 	cmp  %o0, 0                                    
400130b4:	14 80 00 3b 	bg  400131a0 <rtems_rfs_group_bitmap_alloc+0x18c><== NEVER TAKEN
400130b8:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    if (rtems_rfs_fs_release_bitmaps (fs))                            
400130bc:	c2 06 00 00 	ld  [ %i0 ], %g1                               
400130c0:	80 88 60 01 	btst  1, %g1                                   
400130c4:	22 80 00 3b 	be,a   400131b0 <rtems_rfs_group_bitmap_alloc+0x19c><== ALWAYS TAKEN
400130c8:	d2 04 80 00 	ld  [ %l2 ], %o1                               
      rtems_rfs_bitmap_release_buffer (fs, bitmap);                   
                                                                      
    if (allocated)                                                    
400130cc:	c2 0f bf fb 	ldub  [ %fp + -5 ], %g1                        <== NOT EXECUTED
400130d0:	80 a0 60 00 	cmp  %g1, 0                                    
400130d4:	12 80 00 3b 	bne  400131c0 <rtems_rfs_group_bitmap_alloc+0x1ac>
400130d8:	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)                                                       
400130dc:	22 80 00 07 	be,a   400130f8 <rtems_rfs_group_bitmap_alloc+0xe4><== NEVER TAKEN
400130e0:	b2 06 60 01 	inc  %i1                                       <== NOT EXECUTED
      direction = direction > 0 ? -1 : 1;                             
400130e4:	80 a7 20 00 	cmp  %i4, 0                                    
400130e8:	04 80 00 03 	ble  400130f4 <rtems_rfs_group_bitmap_alloc+0xe0><== NEVER TAKEN
400130ec:	b8 10 20 01 	mov  1, %i4                                    
400130f0:	b8 10 3f ff 	mov  -1, %i4                                   
                                                                      
    offset++;                                                         
400130f4:	b2 06 60 01 	inc  %i1                                       
   */                                                                 
  while (true)                                                        
  {                                                                   
    rtems_rfs_bitmap_control* bitmap;                                 
    int                       group;                                  
    bool                      allocated = false;                      
400130f8:	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);                       
400130fc:	90 10 00 1c 	mov  %i4, %o0                                  
40013100:	7f ff bd 2e 	call  400025b8 <.umul>                         
40013104:	92 10 00 19 	mov  %i1, %o1                                  
    if (offset)                                                       
      bit = direction > 0 ? 0 : size - 1;                             
40013108:	82 10 20 00 	clr  %g1                                       
4001310c:	80 a7 20 00 	cmp  %i4, 0                                    
40013110:	04 80 00 17 	ble  4001316c <rtems_rfs_group_bitmap_alloc+0x158><== ALWAYS TAKEN
40013114:	ba 02 00 11 	add  %o0, %l1, %i5                             
40013118:	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))                    
4001311c:	80 a7 60 00 	cmp  %i5, 0                                    
40013120:	36 bf ff d4 	bge,a   40013070 <rtems_rfs_group_bitmap_alloc+0x5c>
40013124:	c2 06 20 24 	ld  [ %i0 + 0x24 ], %g1                        
    {                                                                 
      if (!updown)                                                    
40013128:	80 8c 20 ff 	btst  0xff, %l0                                
4001312c:	02 80 00 13 	be  40013178 <rtems_rfs_group_bitmap_alloc+0x164>
40013130:	80 a7 20 00 	cmp  %i4, 0                                    
        break;                                                        
      direction = direction > 0 ? -1 : 1;                             
40013134:	04 80 00 03 	ble  40013140 <rtems_rfs_group_bitmap_alloc+0x12c><== ALWAYS TAKEN
40013138:	b8 10 20 01 	mov  1, %i4                                    
4001313c:	b8 10 3f ff 	mov  -1, %i4                                   <== NOT EXECUTED
   */                                                                 
  while (true)                                                        
  {                                                                   
    rtems_rfs_bitmap_control* bitmap;                                 
    int                       group;                                  
    bool                      allocated = false;                      
40013140:	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);                       
40013144:	90 10 00 1c 	mov  %i4, %o0                                  
40013148:	7f ff bd 1c 	call  400025b8 <.umul>                         
4001314c:	92 10 00 19 	mov  %i1, %o1                                  
    if ((group < 0) || (group >= fs->group_count))                    
    {                                                                 
      if (!updown)                                                    
        break;                                                        
      direction = direction > 0 ? -1 : 1;                             
      updown = false;                                                 
40013150:	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)                                                       
40013154:	80 a6 60 00 	cmp  %i1, 0                                    
40013158:	02 bf ff c2 	be  40013060 <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
4001315c:	ba 02 00 11 	add  %o0, %l1, %i5                             
      bit = direction > 0 ? 0 : size - 1;                             
40013160:	80 a7 20 00 	cmp  %i4, 0                                    
40013164:	14 bf ff ed 	bg  40013118 <rtems_rfs_group_bitmap_alloc+0x104><== ALWAYS TAKEN
40013168:	82 10 20 00 	clr  %g1                                       
4001316c:	82 04 ff ff 	add  %l3, -1, %g1                              
40013170:	10 bf ff eb 	b  4001311c <rtems_rfs_group_bitmap_alloc+0x108>
40013174:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
      direction = direction > 0 ? -1 : 1;                             
                                                                      
    offset++;                                                         
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))                
40013178:	90 10 20 00 	clr  %o0                                       
4001317c:	40 00 07 ca 	call  400150a4 <rtems_rfs_trace>               
40013180:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
40013184:	80 8a 20 ff 	btst  0xff, %o0                                
40013188:	22 80 00 06 	be,a   400131a0 <rtems_rfs_group_bitmap_alloc+0x18c><== ALWAYS TAKEN
4001318c:	90 10 20 1c 	mov  0x1c, %o0                                 
    printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");  
40013190:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40013194:	40 00 48 92 	call  400253dc <puts>                          <== NOT EXECUTED
40013198:	90 12 22 b8 	or  %o0, 0x2b8, %o0	! 40036eb8 <_CPU_Trap_slot_template+0x9d0><== NOT EXECUTED
                                                                      
  return ENOSPC;                                                      
4001319c:	90 10 20 1c 	mov  0x1c, %o0                                 <== NOT EXECUTED
}                                                                     
400131a0:	81 c7 e0 08 	ret                                            
400131a4:	91 e8 00 08 	restore  %g0, %o0, %o0                         
    }                                                                 
                                                                      
   if (inode)                                                         
      bitmap = &fs->groups[group].inode_bitmap;                       
    else                                                              
      bitmap = &fs->groups[group].block_bitmap;                       
400131a8:	10 bf ff bd 	b  4001309c <rtems_rfs_group_bitmap_alloc+0x88>
400131ac:	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);                   
400131b0:	40 00 29 22 	call  4001d638 <rtems_rfs_buffer_handle_release>
400131b4:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
    if (allocated)                                                    
400131b8:	10 bf ff c6 	b  400130d0 <rtems_rfs_group_bitmap_alloc+0xbc>
400131bc:	c2 0f bf fb 	ldub  [ %fp + -5 ], %g1                        
    {                                                                 
      if (inode)                                                      
400131c0:	80 a6 a0 00 	cmp  %i2, 0                                    
400131c4:	32 80 00 15 	bne,a   40013218 <rtems_rfs_group_bitmap_alloc+0x204>
400131c8:	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);    
400131cc:	c2 06 20 20 	ld  [ %i0 + 0x20 ], %g1                        
400131d0:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
400131d4:	a8 05 40 14 	add  %l5, %l4, %l4                             
400131d8:	c2 00 40 14 	ld  [ %g1 + %l4 ], %g1                         
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))            
400131dc:	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);    
400131e0:	82 00 80 01 	add  %g2, %g1, %g1                             
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))            
400131e4:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
400131e8:	40 00 07 af 	call  400150a4 <rtems_rfs_trace>               
400131ec:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
400131f0:	80 8a 20 ff 	btst  0xff, %o0                                
400131f4:	02 80 00 07 	be  40013210 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
400131f8:	13 10 00 db 	sethi  %hi(0x40036c00), %o1                    
        printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
400131fc:	92 12 62 78 	or  %o1, 0x278, %o1	! 40036e78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40013200:	d4 06 c0 00 	ld  [ %i3 ], %o2                               <== NOT EXECUTED
40013204:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40013208:	40 00 47 dd 	call  4002517c <printf>                        <== NOT EXECUTED
4001320c:	90 12 22 80 	or  %o0, 0x280, %o0	! 40036e80 <_CPU_Trap_slot_template+0x998><== NOT EXECUTED
                inode ? "inode" : "block", *result);                  
      return 0;                                                       
40013210:	10 bf ff e4 	b  400131a0 <rtems_rfs_group_bitmap_alloc+0x18c>
40013214:	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);             
40013218:	90 10 00 1d 	mov  %i5, %o0                                  
4001321c:	7f ff bc e7 	call  400025b8 <.umul>                         
40013220:	fa 07 bf fc 	ld  [ %fp + -4 ], %i5                          
40013224:	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))            
40013228:	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);             
4001322c:	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))            
40013230:	90 10 20 00 	clr  %o0                                       
40013234:	40 00 07 9c 	call  400150a4 <rtems_rfs_trace>               
40013238:	fa 26 c0 00 	st  %i5, [ %i3 ]                               
4001323c:	80 8a 20 ff 	btst  0xff, %o0                                
40013240:	02 bf ff f4 	be  40013210 <rtems_rfs_group_bitmap_alloc+0x1fc><== ALWAYS TAKEN
40013244:	13 10 00 db 	sethi  %hi(0x40036c00), %o1                    
        printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
40013248:	10 bf ff ee 	b  40013200 <rtems_rfs_group_bitmap_alloc+0x1ec><== NOT EXECUTED
4001324c:	92 12 62 70 	or  %o1, 0x270, %o1	! 40036e70 <_CPU_Trap_slot_template+0x988><== NOT EXECUTED
                                                                      

40013250 <rtems_rfs_group_bitmap_free>: int rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs, bool inode, rtems_rfs_bitmap_bit no) {
40013250:	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))                
40013254:	90 10 20 00 	clr  %o0                                       
40013258:	13 00 00 80 	sethi  %hi(0x20000), %o1                       
4001325c:	40 00 07 92 	call  400150a4 <rtems_rfs_trace>               
40013260:	ba 10 00 18 	mov  %i0, %i5                                  
40013264:	80 8a 20 ff 	btst  0xff, %o0                                
40013268:	02 80 00 0b 	be  40013294 <rtems_rfs_group_bitmap_free+0x44><== ALWAYS TAKEN
4001326c:	80 a6 60 00 	cmp  %i1, 0                                    
    printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",   
40013270:	12 80 00 3a 	bne  40013358 <rtems_rfs_group_bitmap_free+0x108><== NOT EXECUTED
40013274:	13 10 00 db 	sethi  %hi(0x40036c00), %o1                    <== NOT EXECUTED
40013278:	13 10 00 db 	sethi  %hi(0x40036c00), %o1                    <== NOT EXECUTED
4001327c:	92 12 62 78 	or  %o1, 0x278, %o1	! 40036e78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40013280:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40013284:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40013288:	40 00 47 bd 	call  4002517c <printf>                        <== NOT EXECUTED
4001328c:	90 12 22 f0 	or  %o0, 0x2f0, %o0                            <== NOT EXECUTED
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
40013290:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
40013294:	22 80 00 1a 	be,a   400132fc <rtems_rfs_group_bitmap_free+0xac>
40013298:	f8 07 60 28 	ld  [ %i5 + 0x28 ], %i4                        
  {                                                                   
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
4001329c:	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;                                         
400132a0:	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);                           
400132a4:	92 10 00 1c 	mov  %i4, %o1                                  
400132a8:	40 00 79 4b 	call  400317d4 <.urem>                         
400132ac:	90 10 00 1a 	mov  %i2, %o0                                  
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
400132b0:	92 10 00 1c 	mov  %i4, %o1                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
400132b4:	b6 10 00 08 	mov  %o0, %i3                                  
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
400132b8:	7f ff bc fa 	call  400026a0 <.udiv>                         
400132bc:	90 10 00 1a 	mov  %i2, %o0                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
400132c0:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        
400132c4:	83 2a 20 04 	sll  %o0, 4, %g1                               
400132c8:	91 2a 20 06 	sll  %o0, 6, %o0                               
400132cc:	90 00 40 08 	add  %g1, %o0, %o0                             
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
400132d0:	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;                         
400132d4:	b8 07 00 08 	add  %i4, %o0, %i4                             
400132d8:	b8 07 20 2c 	add  %i4, 0x2c, %i4                            
  else                                                                
    bitmap = &fs->groups[group].block_bitmap;                         
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
400132dc:	40 00 23 33 	call  4001bfa8 <rtems_rfs_bitmap_map_clear>    
400132e0:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
400132e4:	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);                      
400132e8:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
400132ec:	40 00 28 d3 	call  4001d638 <rtems_rfs_buffer_handle_release>
400132f0:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  return rc;                                                          
}                                                                     
400132f4:	81 c7 e0 08 	ret                                            
400132f8:	81 e8 00 00 	restore                                        
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
  }                                                                   
  else                                                                
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
400132fc:	b4 06 bf ff 	add  %i2, -1, %i2                              
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
40013300:	92 10 00 1c 	mov  %i4, %o1                                  
40013304:	40 00 79 34 	call  400317d4 <.urem>                         
40013308:	90 10 00 1a 	mov  %i2, %o0                                  
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
4001330c:	92 10 00 1c 	mov  %i4, %o1                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
40013310:	b6 10 00 08 	mov  %o0, %i3                                  
  {                                                                   
    no -= RTEMS_RFS_SUPERBLOCK_SIZE;                                  
    size = fs->group_blocks;                                          
  }                                                                   
                                                                      
  group = no / size;                                                  
40013314:	7f ff bc e3 	call  400026a0 <.udiv>                         
40013318:	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;                         
4001331c:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        
40013320:	83 2a 20 04 	sll  %o0, 4, %g1                               
40013324:	91 2a 20 06 	sll  %o0, 6, %o0                               
40013328:	90 00 40 08 	add  %g1, %o0, %o0                             
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
4001332c:	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;                         
40013330:	b8 07 00 08 	add  %i4, %o0, %i4                             
40013334:	b8 07 20 08 	add  %i4, 8, %i4                               
                                                                      
  rc = rtems_rfs_bitmap_map_clear (bitmap, bit);                      
40013338:	40 00 23 1c 	call  4001bfa8 <rtems_rfs_bitmap_map_clear>    
4001333c:	90 10 00 1c 	mov  %i4, %o0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
40013340:	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);                      
40013344:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
40013348:	40 00 28 bc 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001334c:	90 10 00 1d 	mov  %i5, %o0                                  
                                                                      
  return rc;                                                          
}                                                                     
40013350:	81 c7 e0 08 	ret                                            
40013354:	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",   
40013358:	10 bf ff ca 	b  40013280 <rtems_rfs_group_bitmap_free+0x30> <== NOT EXECUTED
4001335c:	92 12 62 70 	or  %o1, 0x270, %o1                            <== NOT EXECUTED
                                                                      

40013360 <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) {
40013360:	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))                
40013364:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40013368:	13 00 00 80 	sethi  %hi(0x20000), %o1                       <== NOT EXECUTED
4001336c:	40 00 07 4e 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40013370:	ba 10 00 18 	mov  %i0, %i5                                  <== NOT EXECUTED
40013374:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40013378:	02 80 00 0b 	be  400133a4 <rtems_rfs_group_bitmap_test+0x44><== NOT EXECUTED
4001337c:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
    printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",   
40013380:	12 80 00 2f 	bne  4001343c <rtems_rfs_group_bitmap_test+0xdc><== NOT EXECUTED
40013384:	13 10 00 db 	sethi  %hi(0x40036c00), %o1                    <== NOT EXECUTED
40013388:	13 10 00 db 	sethi  %hi(0x40036c00), %o1                    <== NOT EXECUTED
4001338c:	92 12 62 78 	or  %o1, 0x278, %o1	! 40036e78 <_CPU_Trap_slot_template+0x990><== NOT EXECUTED
40013390:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40013394:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40013398:	40 00 47 79 	call  4002517c <printf>                        <== NOT EXECUTED
4001339c:	90 12 23 20 	or  %o0, 0x320, %o0                            <== NOT EXECUTED
            inode ? "inode" : "block", no);                           
                                                                      
  if (inode)                                                          
400133a0:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
400133a4:	22 80 00 0b 	be,a   400133d0 <rtems_rfs_group_bitmap_test+0x70><== NOT EXECUTED
400133a8:	c2 07 60 04 	ld  [ %i5 + 4 ], %g1                           <== NOT EXECUTED
  {                                                                   
    if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs))) 
400133ac:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
400133b0:	04 80 00 06 	ble  400133c8 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
400133b4:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
400133b8:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        <== NOT EXECUTED
400133bc:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
400133c0:	28 80 00 21 	bleu,a   40013444 <rtems_rfs_group_bitmap_test+0xe4><== NOT EXECUTED
400133c4:	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;                                                          
}                                                                     
400133c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400133cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    no -= RTEMS_RFS_ROOT_INO;                                         
    size = fs->group_inodes;                                          
  }                                                                   
  else                                                                
  {                                                                   
    if (no >= rtems_rfs_fs_blocks (fs))                               
400133d0:	80 a6 80 01 	cmp  %i2, %g1                                  <== NOT EXECUTED
400133d4:	1a bf ff fd 	bcc  400133c8 <rtems_rfs_group_bitmap_test+0x68><== NOT EXECUTED
400133d8:	b0 10 20 16 	mov  0x16, %i0                                 <== NOT EXECUTED
        return EINVAL;                                                
    size = fs->group_blocks;                                          
400133dc:	f8 07 60 28 	ld  [ %i5 + 0x28 ], %i4                        <== NOT EXECUTED
  }                                                                   
                                                                      
  group = no / size;                                                  
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
400133e0:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
400133e4:	40 00 78 fc 	call  400317d4 <.urem>                         <== NOT EXECUTED
400133e8:	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;                                                  
400133ec:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
400133f0:	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;                                                  
400133f4:	7f ff bc ab 	call  400026a0 <.udiv>                         <== NOT EXECUTED
400133f8:	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;                         
400133fc:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        <== NOT EXECUTED
40013400:	83 2a 20 04 	sll  %o0, 4, %g1                               <== NOT EXECUTED
40013404:	91 2a 20 06 	sll  %o0, 6, %o0                               <== NOT EXECUTED
40013408:	90 00 40 08 	add  %g1, %o0, %o0                             <== NOT EXECUTED
4001340c:	b8 07 00 08 	add  %i4, %o0, %i4                             <== NOT EXECUTED
40013410:	b8 07 20 08 	add  %i4, 8, %i4                               <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);                
40013414:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40013418:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
4001341c:	40 00 23 06 	call  4001c034 <rtems_rfs_bitmap_map_test>     <== NOT EXECUTED
40013420:	94 10 00 1b 	mov  %i3, %o2                                  <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
40013424:	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);                
40013428:	b0 10 00 08 	mov  %o0, %i0                                  <== NOT EXECUTED
                                                                      
  rtems_rfs_bitmap_release_buffer (fs, bitmap);                       
4001342c:	40 00 28 83 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40013430:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
40013434:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013438:	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",   
4001343c:	10 bf ff d5 	b  40013390 <rtems_rfs_group_bitmap_test+0x30> <== NOT EXECUTED
40013440:	92 12 62 70 	or  %o1, 0x270, %o1                            <== NOT EXECUTED
                                                                      
  if (inode)                                                          
  {                                                                   
    if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs))) 
        return EINVAL;                                                
    no -= RTEMS_RFS_ROOT_INO;                                         
40013444:	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);                           
40013448:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
4001344c:	40 00 78 e2 	call  400317d4 <.urem>                         <== NOT EXECUTED
40013450:	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;                                                  
40013454:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
40013458:	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;                                                  
4001345c:	7f ff bc 91 	call  400026a0 <.udiv>                         <== NOT EXECUTED
40013460:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
  bit = (rtems_rfs_bitmap_bit) (no % size);                           
                                                                      
  if (inode)                                                          
    bitmap = &fs->groups[group].inode_bitmap;                         
40013464:	f8 07 60 20 	ld  [ %i5 + 0x20 ], %i4                        <== NOT EXECUTED
40013468:	83 2a 20 04 	sll  %o0, 4, %g1                               <== NOT EXECUTED
4001346c:	91 2a 20 06 	sll  %o0, 6, %o0                               <== NOT EXECUTED
40013470:	90 00 40 08 	add  %g1, %o0, %o0                             <== NOT EXECUTED
40013474:	b8 07 00 08 	add  %i4, %o0, %i4                             <== NOT EXECUTED
40013478:	10 bf ff e7 	b  40013414 <rtems_rfs_group_bitmap_test+0xb4> <== NOT EXECUTED
4001347c:	b8 07 20 2c 	add  %i4, 0x2c, %i4                            <== NOT EXECUTED
                                                                      

40012f68 <rtems_rfs_group_close>: int rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group) {
40012f68:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int result = 0;                                                     
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))                  
40012f6c:	90 10 20 00 	clr  %o0                                       
40012f70:	13 00 00 40 	sethi  %hi(0x10000), %o1                       
40012f74:	40 00 08 4c 	call  400150a4 <rtems_rfs_trace>               
40012f78:	ba 10 00 18 	mov  %i0, %i5                                  
40012f7c:	80 8a 20 ff 	btst  0xff, %o0                                
40012f80:	32 80 00 17 	bne,a   40012fdc <rtems_rfs_group_close+0x74>  <== NEVER TAKEN
40012f84:	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);                 
40012f88:	40 00 25 24 	call  4001c418 <rtems_rfs_bitmap_close>        
40012f8c:	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);                       
40012f90:	92 06 60 44 	add  %i1, 0x44, %o1                            
40012f94:	b8 10 00 08 	mov  %o0, %i4                                  
40012f98:	40 00 29 a8 	call  4001d638 <rtems_rfs_buffer_handle_release>
40012f9c:	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);                 
40012fa0:	90 06 60 08 	add  %i1, 8, %o0                               
  handle->dirty = false;                                              
40012fa4:	c0 2e 60 44 	clrb  [ %i1 + 0x44 ]                           
  handle->bnum  = 0;                                                  
40012fa8:	c0 26 60 48 	clr  [ %i1 + 0x48 ]                            
40012fac:	40 00 25 1b 	call  4001c418 <rtems_rfs_bitmap_close>        
40012fb0:	c0 26 60 4c 	clr  [ %i1 + 0x4c ]                            
  if (rc > 0)                                                         
40012fb4:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40012fb8:	04 80 00 0d 	ble  40012fec <rtems_rfs_group_close+0x84>     <== ALWAYS TAKEN
40012fbc:	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);                       
40012fc0:	40 00 29 9e 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012fc4:	92 06 60 20 	add  %i1, 0x20, %o1                            <== NOT EXECUTED
  handle->dirty = false;                                              
40012fc8:	c0 2e 60 20 	clrb  [ %i1 + 0x20 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40012fcc:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
40012fd0:	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;                                                      
}                                                                     
40012fd4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012fd8:	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);
40012fdc:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012fe0:	40 00 48 67 	call  4002517c <printf>                        <== NOT EXECUTED
40012fe4:	90 12 22 48 	or  %o0, 0x248, %o0	! 40036e48 <_CPU_Trap_slot_template+0x960><== NOT EXECUTED
40012fe8:	30 bf ff e8 	b,a   40012f88 <rtems_rfs_group_close+0x20>    <== NOT EXECUTED
40012fec:	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);                       
40012ff0:	92 06 60 20 	add  %i1, 0x20, %o1                            
40012ff4:	40 00 29 91 	call  4001d638 <rtems_rfs_buffer_handle_release>
40012ff8:	b1 3e 20 1f 	sra  %i0, 0x1f, %i0                            
40012ffc:	b0 0f 00 18 	and  %i4, %i0, %i0                             
  handle->dirty = false;                                              
40013000:	c0 2e 60 20 	clrb  [ %i1 + 0x20 ]                           
  handle->bnum  = 0;                                                  
40013004:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            
  handle->buffer = NULL;                                              
40013008:	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;                                                      
}                                                                     
4001300c:	81 c7 e0 08 	ret                                            
40013010:	81 e8 00 00 	restore                                        
                                                                      

40012d34 <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) {
40012d34:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (base >= rtems_rfs_fs_blocks (fs))                               
40012d38:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
40012d3c:	80 a0 40 19 	cmp  %g1, %i1                                  
40012d40:	08 80 00 44 	bleu  40012e50 <rtems_rfs_group_open+0x11c>    <== NEVER TAKEN
40012d44:	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))                      
40012d48:	84 06 80 19 	add  %i2, %i1, %g2                             
40012d4c:	80 a0 40 02 	cmp  %g1, %g2                                  
40012d50:	28 80 00 02 	bleu,a   40012d58 <rtems_rfs_group_open+0x24>  <== ALWAYS TAKEN
40012d54:	b4 20 40 19 	sub  %g1, %i1, %i2                             
40012d58:	80 a6 80 1b 	cmp  %i2, %i3                                  
40012d5c:	18 80 00 25 	bgu  40012df0 <rtems_rfs_group_open+0xbc>      <== ALWAYS TAKEN
40012d60:	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))                   
40012d64:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40012d68:	40 00 08 cf 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40012d6c:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
40012d70:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40012d74:	12 80 00 27 	bne  40012e10 <rtems_rfs_group_open+0xdc>      <== NOT EXECUTED
40012d78:	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;                                                 
40012d7c:	f2 27 00 00 	st  %i1, [ %i4 ]                               <== NOT EXECUTED
  group->size = size;                                                 
40012d80:	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;                                              
40012d84:	c0 2f 20 20 	clrb  [ %i4 + 0x20 ]                           
  handle->bnum  = 0;                                                  
40012d88:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            
  handle->buffer = NULL;                                              
40012d8c:	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,               
40012d90:	a0 07 20 08 	add  %i4, 8, %l0                               
40012d94:	b6 07 20 20 	add  %i4, 0x20, %i3                            
40012d98:	90 10 00 10 	mov  %l0, %o0                                  
40012d9c:	92 10 00 1d 	mov  %i5, %o1                                  
40012da0:	94 10 00 1b 	mov  %i3, %o2                                  
40012da4:	96 10 00 1a 	mov  %i2, %o3                                  
40012da8:	40 00 25 8b 	call  4001c3d4 <rtems_rfs_bitmap_open>         
40012dac:	98 10 00 19 	mov  %i1, %o4                                  
                              &group->block_bitmap_buffer, size,      
                              group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
  if (rc > 0)                                                         
40012db0:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40012db4:	04 80 00 37 	ble  40012e90 <rtems_rfs_group_open+0x15c>     <== ALWAYS TAKEN
40012db8:	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);                       
40012dbc:	40 00 2a 1f 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012dc0:	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))                 
40012dc4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40012dc8:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
  handle->dirty = false;                                              
40012dcc:	c0 2f 20 20 	clrb  [ %i4 + 0x20 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40012dd0:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            <== NOT EXECUTED
40012dd4:	40 00 08 b4 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40012dd8:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            <== NOT EXECUTED
40012ddc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40012de0:	12 80 00 13 	bne  40012e2c <rtems_rfs_group_open+0xf8>      <== NOT EXECUTED
40012de4:	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;                                                           
}                                                                     
40012de8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012dec:	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))                   
40012df0:	90 10 20 00 	clr  %o0                                       
40012df4:	13 00 00 20 	sethi  %hi(0x8000), %o1                        
40012df8:	40 00 08 ab 	call  400150a4 <rtems_rfs_trace>               
40012dfc:	a2 10 00 1b 	mov  %i3, %l1                                  
40012e00:	80 8a 20 ff 	btst  0xff, %o0                                
40012e04:	22 bf ff df 	be,a   40012d80 <rtems_rfs_group_open+0x4c>    <== ALWAYS TAKEN
40012e08:	f2 27 00 00 	st  %i1, [ %i4 ]                               
    printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
40012e0c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40012e10:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012e14:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40012e18:	96 10 00 11 	mov  %l1, %o3                                  <== NOT EXECUTED
40012e1c:	40 00 48 d8 	call  4002517c <printf>                        <== NOT EXECUTED
40012e20:	90 12 21 90 	or  %o0, 0x190, %o0                            <== NOT EXECUTED
            base, size, inodes);                                      
                                                                      
  group->base = base;                                                 
40012e24:	10 bf ff d7 	b  40012d80 <rtems_rfs_group_open+0x4c>        <== NOT EXECUTED
40012e28:	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",
40012e2c:	40 00 4d 1e 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012e30:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40012e34:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
40012e38:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012e3c:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012e40:	40 00 48 cf 	call  4002517c <printf>                        <== NOT EXECUTED
40012e44:	90 12 21 c8 	or  %o0, 0x1c8, %o0	! 40036dc8 <_CPU_Trap_slot_template+0x8e0><== NOT EXECUTED
40012e48:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012e4c:	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))                 
40012e50:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40012e54:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
40012e58:	40 00 08 93 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40012e5c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
40012e60:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40012e64:	02 80 00 3f 	be  40012f60 <rtems_rfs_group_open+0x22c>      <== NOT EXECUTED
40012e68:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
40012e6c:	40 00 4d 0e 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012e70:	90 10 20 05 	mov  5, %o0	! 5 <PROM_START+0x5>               <== NOT EXECUTED
40012e74:	92 10 20 05 	mov  5, %o1                                    <== NOT EXECUTED
40012e78:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012e7c:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012e80:	40 00 48 bf 	call  4002517c <printf>                        <== NOT EXECUTED
40012e84:	90 12 21 50 	or  %o0, 0x150, %o0	! 40036d50 <_CPU_Trap_slot_template+0x868><== NOT EXECUTED
40012e88:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012e8c:	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,               
40012e90:	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;                                              
40012e94:	c0 2f 20 44 	clrb  [ %i4 + 0x44 ]                           
  handle->bnum  = 0;                                                  
40012e98:	c0 27 20 48 	clr  [ %i4 + 0x48 ]                            
  handle->buffer = NULL;                                              
40012e9c:	c0 27 20 4c 	clr  [ %i4 + 0x4c ]                            
40012ea0:	b4 07 20 44 	add  %i4, 0x44, %i2                            
40012ea4:	90 07 20 2c 	add  %i4, 0x2c, %o0                            
40012ea8:	92 10 00 1d 	mov  %i5, %o1                                  
40012eac:	94 10 00 1a 	mov  %i2, %o2                                  
40012eb0:	96 10 00 11 	mov  %l1, %o3                                  
40012eb4:	40 00 25 48 	call  4001c3d4 <rtems_rfs_bitmap_open>         
40012eb8:	98 03 20 01 	inc  %o4                                       
                              &group->inode_bitmap_buffer, inodes,    
                              group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
  if (rc > 0)                                                         
40012ebc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40012ec0:	04 80 00 1e 	ble  40012f38 <rtems_rfs_group_open+0x204>     <== ALWAYS TAKEN
40012ec4:	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);                       
40012ec8:	40 00 29 dc 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012ecc:	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);                    
40012ed0:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
40012ed4:	c0 2f 20 44 	clrb  [ %i4 + 0x44 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40012ed8:	c0 27 20 48 	clr  [ %i4 + 0x48 ]                            <== NOT EXECUTED
40012edc:	40 00 25 4f 	call  4001c418 <rtems_rfs_bitmap_close>        <== NOT EXECUTED
40012ee0:	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);                       
40012ee4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40012ee8:	40 00 29 d4 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
40012eec:	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))                 
40012ef0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40012ef4:	13 00 00 20 	sethi  %hi(0x8000), %o1                        <== NOT EXECUTED
  handle->dirty = false;                                              
40012ef8:	c0 2f 20 20 	clrb  [ %i4 + 0x20 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40012efc:	c0 27 20 24 	clr  [ %i4 + 0x24 ]                            <== NOT EXECUTED
40012f00:	40 00 08 69 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40012f04:	c0 27 20 28 	clr  [ %i4 + 0x28 ]                            <== NOT EXECUTED
40012f08:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40012f0c:	02 80 00 15 	be  40012f60 <rtems_rfs_group_open+0x22c>      <== NOT EXECUTED
40012f10:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
40012f14:	40 00 4c e4 	call  400262a4 <strerror>                      <== NOT EXECUTED
40012f18:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40012f1c:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
40012f20:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40012f24:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40012f28:	40 00 48 95 	call  4002517c <printf>                        <== NOT EXECUTED
40012f2c:	90 12 22 08 	or  %o0, 0x208, %o0	! 40036e08 <_CPU_Trap_slot_template+0x920><== NOT EXECUTED
40012f30:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40012f34:	81 e8 00 00 	restore                                        <== NOT EXECUTED
              rc, strerror (rc));                                     
    return rc;                                                        
  }                                                                   
                                                                      
  if (rtems_rfs_fs_release_bitmaps (fs))                              
40012f38:	c2 07 40 00 	ld  [ %i5 ], %g1                               
40012f3c:	80 88 60 01 	btst  1, %g1                                   
40012f40:	12 bf ff aa 	bne  40012de8 <rtems_rfs_group_open+0xb4>      <== NEVER TAKEN
40012f44:	b0 10 20 00 	clr  %i0                                       
  {                                                                   
    rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);       
40012f48:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
40012f4c:	40 00 29 bb 	call  4001d638 <rtems_rfs_buffer_handle_release>
40012f50:	90 10 00 1d 	mov  %i5, %o0                                  
    rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);       
40012f54:	d2 07 20 2c 	ld  [ %i4 + 0x2c ], %o1                        
40012f58:	40 00 29 b8 	call  4001d638 <rtems_rfs_buffer_handle_release>
40012f5c:	90 10 00 1d 	mov  %i5, %o0                                  
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40012f60:	81 c7 e0 08 	ret                                            
40012f64:	81 e8 00 00 	restore                                        
                                                                      

40013480 <rtems_rfs_group_usage>: size_t* blocks, size_t* inodes) { int g; *blocks = 0;
40013480:	c0 22 40 00 	clr  [ %o1 ]                                   <== NOT EXECUTED
  *inodes = 0;                                                        
40013484:	c0 22 80 00 	clr  [ %o2 ]                                   <== NOT EXECUTED
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
40013488:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        <== NOT EXECUTED
4001348c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40013490:	04 80 00 14 	ble  400134e0 <rtems_rfs_group_usage+0x60>     <== NOT EXECUTED
40013494:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
40013498:	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) -               
4001349c:	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 +=                                                        
400134a0:	c8 00 60 18 	ld  [ %g1 + 0x18 ], %g4                        <== NOT EXECUTED
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
400134a4:	c6 02 40 00 	ld  [ %o1 ], %g3                               <== NOT EXECUTED
  int g;                                                              
                                                                      
  *blocks = 0;                                                        
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
400134a8:	84 00 a0 01 	inc  %g2                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_group* group = &fs->groups[g];                          
    *blocks +=                                                        
      rtems_rfs_bitmap_map_size(&group->block_bitmap) -               
400134ac:	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 +=                                                        
400134b0:	86 20 c0 04 	sub  %g3, %g4, %g3                             <== NOT EXECUTED
400134b4:	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) -              
400134b8:	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 +=                                                        
400134bc:	c8 00 60 3c 	ld  [ %g1 + 0x3c ], %g4                        <== NOT EXECUTED
      rtems_rfs_bitmap_map_size (&group->inode_bitmap) -              
400134c0:	c6 02 80 00 	ld  [ %o2 ], %g3                               <== NOT EXECUTED
400134c4:	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 +=                                                        
400134c8:	86 20 c0 04 	sub  %g3, %g4, %g3                             <== NOT EXECUTED
400134cc:	c6 22 80 00 	st  %g3, [ %o2 ]                               <== NOT EXECUTED
  int g;                                                              
                                                                      
  *blocks = 0;                                                        
  *inodes = 0;                                                        
                                                                      
  for (g = 0; g < fs->group_count; g++)                               
400134d0:	c6 02 20 24 	ld  [ %o0 + 0x24 ], %g3                        <== NOT EXECUTED
400134d4:	80 a0 c0 02 	cmp  %g3, %g2                                  <== NOT EXECUTED
400134d8:	14 bf ff f1 	bg  4001349c <rtems_rfs_group_usage+0x1c>      <== NOT EXECUTED
400134dc:	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))                             
400134e0:	c4 02 20 04 	ld  [ %o0 + 4 ], %g2                           <== NOT EXECUTED
400134e4:	c2 02 40 00 	ld  [ %o1 ], %g1                               <== NOT EXECUTED
400134e8:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
400134ec:	38 80 00 02 	bgu,a   400134f4 <rtems_rfs_group_usage+0x74>  <== NOT EXECUTED
400134f0:	82 10 00 02 	mov  %g2, %g1                                  <== NOT EXECUTED
400134f4:	c2 22 40 00 	st  %g1, [ %o1 ]                               <== NOT EXECUTED
    *blocks = rtems_rfs_fs_blocks (fs);                               
  if (*inodes > rtems_rfs_fs_inodes (fs))                             
400134f8:	c4 02 20 14 	ld  [ %o0 + 0x14 ], %g2                        <== NOT EXECUTED
400134fc:	c2 02 80 00 	ld  [ %o2 ], %g1                               <== NOT EXECUTED
40013500:	80 a0 40 02 	cmp  %g1, %g2                                  <== NOT EXECUTED
40013504:	38 80 00 02 	bgu,a   4001350c <rtems_rfs_group_usage+0x8c>  <== NOT EXECUTED
40013508:	82 10 00 02 	mov  %g2, %g1                                  <== NOT EXECUTED
4001350c:	c2 22 80 00 	st  %g1, [ %o2 ]                               <== NOT EXECUTED
    *inodes = rtems_rfs_fs_inodes (fs);                               
                                                                      
  return 0;                                                           
}                                                                     
40013510:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40013514:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
                                                                      

400137e8 <rtems_rfs_inode_close>: } int rtems_rfs_inode_close (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
400137e8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc;                                                             
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                  
400137ec:	90 10 20 00 	clr  %o0                                       
400137f0:	40 00 06 2d 	call  400150a4 <rtems_rfs_trace>               
400137f4:	13 00 02 00 	sethi  %hi(0x80000), %o1                       
400137f8:	80 8a 20 ff 	btst  0xff, %o0                                
400137fc:	32 80 00 16 	bne,a   40013854 <rtems_rfs_inode_close+0x6c>  <== NEVER TAKEN
40013800:	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);                     
40013804:	90 10 00 18 	mov  %i0, %o0                                  
40013808:	92 10 00 19 	mov  %i1, %o1                                  
4001380c:	7f ff ff b6 	call  400136e4 <rtems_rfs_inode_unload>        
40013810:	94 10 20 01 	mov  1, %o2                                    
                                                                      
  if ((rc == 0) && (handle->loads > 0))                               
40013814:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40013818:	32 80 00 0d 	bne,a   4001384c <rtems_rfs_inode_close+0x64>  <== NEVER TAKEN
4001381c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
40013820:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
40013824:	80 a0 60 00 	cmp  %g1, 0                                    
40013828:	04 80 00 08 	ble  40013848 <rtems_rfs_inode_close+0x60>     <== ALWAYS TAKEN
4001382c:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))                
40013830:	13 00 02 00 	sethi  %hi(0x80000), %o1                       <== NOT EXECUTED
40013834:	40 00 06 1c 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40013838:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4001383c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40013840:	32 80 00 0a 	bne,a   40013868 <rtems_rfs_inode_close+0x80>  <== NOT EXECUTED
40013844:	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;                                                    
40013848:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
  return rc;                                                          
}                                                                     
4001384c:	81 c7 e0 08 	ret                                            
40013850:	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);
40013854:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
40013858:	40 00 46 49 	call  4002517c <printf>                        <== NOT EXECUTED
4001385c:	90 12 23 f0 	or  %o0, 0x3f0, %o0	! 40036ff0 <_CPU_Trap_slot_template+0xb08><== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_unload (fs, handle, true);                     
40013860:	10 bf ff ea 	b  40013808 <rtems_rfs_inode_close+0x20>       <== NOT EXECUTED
40013864:	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",       
40013868:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001386c:	40 00 46 44 	call  4002517c <printf>                        <== NOT EXECUTED
40013870:	90 12 20 18 	or  %o0, 0x18, %o0	! 40037018 <_CPU_Trap_slot_template+0xb30><== NOT EXECUTED
              handle->loads);                                         
    rc = EIO;                                                         
  }                                                                   
                                                                      
  handle->ino = 0;                                                    
40013874:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
  return rc;                                                          
}                                                                     
40013878:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001387c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40013b50 <rtems_rfs_inode_create>: uint16_t mode, uint16_t links, uid_t uid, gid_t gid, rtems_rfs_ino* ino) {
40013b50:	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))                 
40013b54:	90 10 20 00 	clr  %o0                                       
                        uint16_t                mode,                 
                        uint16_t                links,                
                        uid_t                   uid,                  
                        gid_t                   gid,                  
                        rtems_rfs_ino*          ino)                  
{                                                                     
40013b58:	e4 17 a0 5e 	lduh  [ %fp + 0x5e ], %l2                      
40013b5c:	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))                 
40013b60:	13 00 10 00 	sethi  %hi(0x400000), %o1                      
40013b64:	40 00 05 50 	call  400150a4 <rtems_rfs_trace>               
40013b68:	a6 0f 30 00 	and  %i4, -4096, %l3                           
40013b6c:	80 8a 20 ff 	btst  0xff, %o0                                
40013b70:	22 80 00 28 	be,a   40013c10 <rtems_rfs_inode_create+0xc0>  <== ALWAYS TAKEN
40013b74:	a7 2c e0 10 	sll  %l3, 0x10, %l3                            
  {                                                                   
    const char* type = "unknown";                                     
    int         c;                                                    
    if (RTEMS_RFS_S_ISDIR (mode))                                     
40013b78:	05 00 00 10 	sethi  %hi(0x4000), %g2                        <== NOT EXECUTED
40013b7c:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
40013b80:	02 80 00 4f 	be  40013cbc <rtems_rfs_inode_create+0x16c>    <== NOT EXECUTED
40013b84:	05 00 00 08 	sethi  %hi(0x2000), %g2                        <== NOT EXECUTED
      type = "dir";                                                   
    else if (RTEMS_RFS_S_ISCHR (mode))                                
40013b88:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
40013b8c:	02 80 00 52 	be  40013cd4 <rtems_rfs_inode_create+0x184>    <== NOT EXECUTED
40013b90:	05 00 00 18 	sethi  %hi(0x6000), %g2                        <== NOT EXECUTED
      type = "char";                                                  
    else if (RTEMS_RFS_S_ISBLK (mode))                                
40013b94:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
40013b98:	02 80 00 4c 	be  40013cc8 <rtems_rfs_inode_create+0x178>    <== NOT EXECUTED
40013b9c:	05 00 00 20 	sethi  %hi(0x8000), %g2                        <== NOT EXECUTED
      type = "block";                                                 
    else if (RTEMS_RFS_S_ISREG (mode))                                
40013ba0:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
40013ba4:	02 80 00 4f 	be  40013ce0 <rtems_rfs_inode_create+0x190>    <== NOT EXECUTED
40013ba8:	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";                                     
40013bac:	29 10 00 dc 	sethi  %hi(0x40037000), %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))                                
40013bb0:	80 a4 c0 02 	cmp  %l3, %g2                                  <== NOT EXECUTED
40013bb4:	02 80 00 4e 	be  40013cec <rtems_rfs_inode_create+0x19c>    <== NOT EXECUTED
40013bb8:	a8 15 20 90 	or  %l4, 0x90, %l4                             <== NOT EXECUTED
      type = "link";                                                  
    printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
40013bbc:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40013bc0:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40013bc4:	40 00 45 6e 	call  4002517c <printf>                        <== NOT EXECUTED
40013bc8:	90 12 20 a0 	or  %o0, 0xa0, %o0	! 400370a0 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
40013bcc:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
40013bd0:	80 a6 e0 00 	cmp  %i3, 0                                    <== NOT EXECUTED
40013bd4:	02 80 00 08 	be  40013bf4 <rtems_rfs_inode_create+0xa4>     <== NOT EXECUTED
40013bd8:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
      printf ("%c", name[c]);                                         
40013bdc:	d0 4e 80 01 	ldsb  [ %i2 + %g1 ], %o0                       <== NOT EXECUTED
40013be0:	40 00 45 d1 	call  40025324 <putchar>                       <== NOT EXECUTED
40013be4:	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++)                                      
40013be8:	80 a4 00 1b 	cmp  %l0, %i3                                  <== NOT EXECUTED
40013bec:	12 bf ff fc 	bne  40013bdc <rtems_rfs_inode_create+0x8c>    <== NOT EXECUTED
40013bf0:	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));
40013bf4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40013bf8:	92 10 00 14 	mov  %l4, %o1                                  <== NOT EXECUTED
40013bfc:	90 12 20 d0 	or  %o0, 0xd0, %o0                             <== NOT EXECUTED
40013c00:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
40013c04:	40 00 45 5e 	call  4002517c <printf>                        <== NOT EXECUTED
40013c08:	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)                                    
40013c0c:	a7 2c e0 10 	sll  %l3, 0x10, %l3                            <== NOT EXECUTED
40013c10:	05 00 00 18 	sethi  %hi(0x6000), %g2                        
40013c14:	83 34 e0 10 	srl  %l3, 0x10, %g1                            
40013c18:	80 a0 40 02 	cmp  %g1, %g2                                  
40013c1c:	02 80 00 15 	be  40013c70 <rtems_rfs_inode_create+0x120>    <== NEVER TAKEN
40013c20:	d4 07 a0 64 	ld  [ %fp + 0x64 ], %o2                        
40013c24:	08 80 00 0c 	bleu  40013c54 <rtems_rfs_inode_create+0x104>  
40013c28:	05 00 00 08 	sethi  %hi(0x2000), %g2                        
40013c2c:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
40013c30:	80 a0 40 02 	cmp  %g1, %g2                                  
40013c34:	02 80 00 0f 	be  40013c70 <rtems_rfs_inode_create+0x120>    
40013c38:	05 00 00 28 	sethi  %hi(0xa000), %g2                        
40013c3c:	80 a0 40 02 	cmp  %g1, %g2                                  
40013c40:	02 80 00 0d 	be  40013c74 <rtems_rfs_inode_create+0x124>    <== ALWAYS TAKEN
40013c44:	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;                                                  
40013c48:	a0 10 20 16 	mov  0x16, %l0                                 <== NOT EXECUTED
    rtems_rfs_inode_free (fs, *ino);                                  
    return rc;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40013c4c:	81 c7 e0 08 	ret                                            
40013c50:	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)                                    
40013c54:	80 a0 40 02 	cmp  %g1, %g2                                  
40013c58:	02 80 00 05 	be  40013c6c <rtems_rfs_inode_create+0x11c>    <== NEVER TAKEN
40013c5c:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
40013c60:	80 a0 40 02 	cmp  %g1, %g2                                  
40013c64:	12 bf ff fa 	bne  40013c4c <rtems_rfs_inode_create+0xfc>    <== NEVER TAKEN
40013c68:	a0 10 20 16 	mov  0x16, %l0                                 
      break;                                                          
    default:                                                          
      return EINVAL;                                                  
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_alloc (fs, parent, ino);                       
40013c6c:	d4 07 a0 64 	ld  [ %fp + 0x64 ], %o2                        
40013c70:	90 10 00 18 	mov  %i0, %o0                                  
40013c74:	7f ff fe 29 	call  40013518 <rtems_rfs_inode_alloc>         
40013c78:	92 10 00 19 	mov  %i1, %o1                                  
  if (rc > 0)                                                         
40013c7c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40013c80:	14 bf ff f3 	bg  40013c4c <rtems_rfs_inode_create+0xfc>     
40013c84:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_open (fs, *ino, &inode, true);                 
40013c88:	90 10 00 18 	mov  %i0, %o0                                  
40013c8c:	d2 00 40 00 	ld  [ %g1 ], %o1                               
40013c90:	94 07 bf d8 	add  %fp, -40, %o2                             
40013c94:	7f ff fe 5d 	call  40013608 <rtems_rfs_inode_open>          
40013c98:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
40013c9c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40013ca0:	04 80 00 16 	ble  40013cf8 <rtems_rfs_inode_create+0x1a8>   <== ALWAYS TAKEN
40013ca4:	90 07 bf d8 	add  %fp, -40, %o0                             
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
40013ca8:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        <== NOT EXECUTED
40013cac:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40013cb0:	7f ff fe 24 	call  40013540 <rtems_rfs_inode_free>          <== NOT EXECUTED
40013cb4:	d2 00 40 00 	ld  [ %g1 ], %o1                               <== NOT EXECUTED
40013cb8:	30 bf ff e5 	b,a   40013c4c <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";                                                   
40013cbc:	29 10 00 dc 	sethi  %hi(0x40037000), %l4                    <== NOT EXECUTED
40013cc0:	10 bf ff bf 	b  40013bbc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40013cc4:	a8 15 20 78 	or  %l4, 0x78, %l4	! 40037078 <_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";                                                 
40013cc8:	29 10 00 db 	sethi  %hi(0x40036c00), %l4                    <== NOT EXECUTED
40013ccc:	10 bf ff bc 	b  40013bbc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40013cd0:	a8 15 22 78 	or  %l4, 0x278, %l4	! 40036e78 <_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";                                                  
40013cd4:	29 10 00 dc 	sethi  %hi(0x40037000), %l4                    <== NOT EXECUTED
40013cd8:	10 bf ff b9 	b  40013bbc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40013cdc:	a8 15 20 80 	or  %l4, 0x80, %l4	! 40037080 <_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";                                                  
40013ce0:	29 10 00 dc 	sethi  %hi(0x40037000), %l4                    <== NOT EXECUTED
40013ce4:	10 bf ff b6 	b  40013bbc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40013ce8:	a8 15 20 88 	or  %l4, 0x88, %l4	! 40037088 <_CPU_Trap_slot_template+0xba0><== NOT EXECUTED
    else if (RTEMS_RFS_S_ISLNK (mode))                                
      type = "link";                                                  
40013cec:	29 10 00 dc 	sethi  %hi(0x40037000), %l4                    <== NOT EXECUTED
40013cf0:	10 bf ff b3 	b  40013bbc <rtems_rfs_inode_create+0x6c>      <== NOT EXECUTED
40013cf4:	a8 15 20 98 	or  %l4, 0x98, %l4	! 40037098 <_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);    
40013cf8:	92 10 00 1d 	mov  %i5, %o1                                  
40013cfc:	94 10 00 1c 	mov  %i4, %o2                                  
40013d00:	96 10 00 12 	mov  %l2, %o3                                  
40013d04:	7f ff ff 3d 	call  400139f8 <rtems_rfs_inode_initialise>    
40013d08:	98 10 00 11 	mov  %l1, %o4                                  
  if (rc > 0)                                                         
40013d0c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40013d10:	14 80 00 13 	bg  40013d5c <rtems_rfs_inode_create+0x20c>    <== NEVER TAKEN
40013d14:	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))                                       
40013d18:	80 a4 c0 01 	cmp  %l3, %g1                                  
40013d1c:	02 80 00 45 	be  40013e30 <rtems_rfs_inode_create+0x2e0>    
40013d20:	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);        
40013d24:	90 10 00 18 	mov  %i0, %o0                                  
40013d28:	92 10 00 19 	mov  %i1, %o1                                  
40013d2c:	94 07 bf b0 	add  %fp, -80, %o2                             
40013d30:	7f ff fe 36 	call  40013608 <rtems_rfs_inode_open>          
40013d34:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
40013d38:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40013d3c:	04 80 00 10 	ble  40013d7c <rtems_rfs_inode_create+0x22c>   <== ALWAYS TAKEN
40013d40:	92 07 bf d8 	add  %fp, -40, %o1                             
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
40013d44:	7f ff fe cf 	call  40013880 <rtems_rfs_inode_delete>        <== NOT EXECUTED
40013d48:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
40013d4c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40013d50:	7f ff fe a6 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40013d54:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40013d58:	30 bf ff bd 	b,a   40013c4c <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);                               
40013d5c:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40013d60:	7f ff fe a2 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40013d64:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_free (fs, *ino);                                  
40013d68:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        <== NOT EXECUTED
40013d6c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40013d70:	7f ff fd f4 	call  40013540 <rtems_rfs_inode_free>          <== NOT EXECUTED
40013d74:	d2 00 40 00 	ld  [ %g1 ], %o1                               <== NOT EXECUTED
40013d78:	30 bf ff b5 	b,a   40013c4c <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);
40013d7c:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
40013d80:	90 10 00 18 	mov  %i0, %o0                                  
40013d84:	d8 00 40 00 	ld  [ %g1 ], %o4                               
40013d88:	92 07 bf b0 	add  %fp, -80, %o1                             
40013d8c:	94 10 00 1a 	mov  %i2, %o2                                  
40013d90:	40 00 29 e5 	call  4001e524 <rtems_rfs_dir_add_entry>       
40013d94:	96 10 00 1b 	mov  %i3, %o3                                  
  if (rc > 0)                                                         
40013d98:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40013d9c:	14 80 00 3c 	bg  40013e8c <rtems_rfs_inode_create+0x33c>    <== NEVER TAKEN
40013da0:	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))                                       
40013da4:	80 a4 c0 01 	cmp  %l3, %g1                                  
40013da8:	12 80 00 15 	bne  40013dfc <rtems_rfs_inode_create+0x2ac>   
40013dac:	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);                  
40013db0:	c2 07 bf bc 	ld  [ %fp + -68 ], %g1                         
  if (links == 0xffff)                                                
    links = 0;                                                        
40013db4:	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);                  
40013db8:	c6 08 40 00 	ldub  [ %g1 ], %g3                             
40013dbc:	c4 08 60 01 	ldub  [ %g1 + 1 ], %g2                         
40013dc0:	87 28 e0 08 	sll  %g3, 8, %g3                               
40013dc4:	84 10 c0 02 	or  %g3, %g2, %g2                              
  if (links == 0xffff)                                                
40013dc8:	87 28 a0 10 	sll  %g2, 0x10, %g3                            
40013dcc:	87 30 e0 10 	srl  %g3, 0x10, %g3                            
    links = 0;                                                        
40013dd0:	86 39 00 03 	xnor  %g4, %g3, %g3                            
40013dd4:	80 a0 00 03 	cmp  %g0, %g3                                  
40013dd8:	86 60 20 00 	subx  %g0, 0, %g3                              
40013ddc:	84 08 80 03 	and  %g2, %g3, %g2                             
    rtems_rfs_inode_set_links (&parent_inode,                         
40013de0:	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);                  
40013de4:	87 30 a0 08 	srl  %g2, 8, %g3                               
40013de8:	c6 28 40 00 	stb  %g3, [ %g1 ]                              
40013dec:	c2 07 bf bc 	ld  [ %fp + -68 ], %g1                         
40013df0:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40013df4:	82 10 20 01 	mov  1, %g1                                    
40013df8:	c2 2f bf c0 	stb  %g1, [ %fp + -64 ]                        
                               rtems_rfs_inode_get_links (&parent_inode) + 1);
                                                                      
  rc = rtems_rfs_inode_close (fs, &parent_inode);                     
40013dfc:	7f ff fe 7b 	call  400137e8 <rtems_rfs_inode_close>         
40013e00:	90 10 00 18 	mov  %i0, %o0                                  
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
40013e04:	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);                     
40013e08:	a0 10 00 08 	mov  %o0, %l0                                  
  if (rc > 0)                                                         
40013e0c:	80 a4 20 00 	cmp  %l0, 0                                    
40013e10:	04 80 00 29 	ble  40013eb4 <rtems_rfs_inode_create+0x364>   <== ALWAYS TAKEN
40013e14:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    rtems_rfs_inode_delete (fs, &inode);                              
40013e18:	7f ff fe 9a 	call  40013880 <rtems_rfs_inode_delete>        <== NOT EXECUTED
40013e1c:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
40013e20:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40013e24:	7f ff fe 71 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40013e28:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40013e2c:	30 bf ff 88 	b,a   40013c4c <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);          
40013e30:	90 10 00 18 	mov  %i0, %o0                                  
40013e34:	d8 00 40 00 	ld  [ %g1 ], %o4                               
40013e38:	92 07 bf d8 	add  %fp, -40, %o1                             
40013e3c:	96 10 20 01 	mov  1, %o3                                    
40013e40:	15 10 00 d3 	sethi  %hi(0x40034c00), %o2                    
40013e44:	40 00 29 b8 	call  4001e524 <rtems_rfs_dir_add_entry>       
40013e48:	94 12 a2 10 	or  %o2, 0x210, %o2	! 40034e10 <flashdisk_ops+0x1c>
    if (rc == 0)                                                      
40013e4c:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40013e50:	12 80 00 0b 	bne  40013e7c <rtems_rfs_inode_create+0x32c>   <== NEVER TAKEN
40013e54:	80 a4 20 00 	cmp  %l0, 0                                    
      rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);     
40013e58:	90 10 00 18 	mov  %i0, %o0                                  
40013e5c:	92 07 bf d8 	add  %fp, -40, %o1                             
40013e60:	96 10 20 02 	mov  2, %o3                                    
40013e64:	15 10 00 d3 	sethi  %hi(0x40034c00), %o2                    
40013e68:	98 10 00 19 	mov  %i1, %o4                                  
40013e6c:	40 00 29 ae 	call  4001e524 <rtems_rfs_dir_add_entry>       
40013e70:	94 12 a2 18 	or  %o2, 0x218, %o2                            
40013e74:	a0 10 00 08 	mov  %o0, %l0                                  
    if (rc > 0)                                                       
40013e78:	80 a4 20 00 	cmp  %l0, 0                                    
40013e7c:	04 bf ff ab 	ble  40013d28 <rtems_rfs_inode_create+0x1d8>   <== ALWAYS TAKEN
40013e80:	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);                              
40013e84:	10 bf ff b0 	b  40013d44 <rtems_rfs_inode_create+0x1f4>     <== NOT EXECUTED
40013e88:	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);                              
40013e8c:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40013e90:	7f ff fe 7c 	call  40013880 <rtems_rfs_inode_delete>        <== NOT EXECUTED
40013e94:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &inode);                               
40013e98:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40013e9c:	7f ff fe 53 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40013ea0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &parent_inode);                        
40013ea4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40013ea8:	7f ff fe 50 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40013eac:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
40013eb0:	30 bf ff 67 	b,a   40013c4c <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);                            
40013eb4:	7f ff fe 4d 	call  400137e8 <rtems_rfs_inode_close>         
40013eb8:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
40013ebc:	a0 92 20 00 	orcc  %o0, 0, %l0                              
40013ec0:	14 bf ff 7b 	bg  40013cac <rtems_rfs_inode_create+0x15c>    <== NEVER TAKEN
40013ec4:	c2 07 a0 64 	ld  [ %fp + 0x64 ], %g1                        
  {                                                                   
    rtems_rfs_inode_free (fs, *ino);                                  
    return rc;                                                        
  }                                                                   
                                                                      
  return 0;                                                           
40013ec8:	10 bf ff 61 	b  40013c4c <rtems_rfs_inode_create+0xfc>      
40013ecc:	a0 10 20 00 	clr  %l0                                       
                                                                      

40013880 <rtems_rfs_inode_delete>: } int rtems_rfs_inode_delete (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
40013880:	9d e3 bf 50 	save  %sp, -176, %sp                           
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))                 
40013884:	90 10 20 00 	clr  %o0                                       
40013888:	40 00 06 07 	call  400150a4 <rtems_rfs_trace>               
4001388c:	13 00 20 00 	sethi  %hi(0x800000), %o1                      
40013890:	80 8a 20 ff 	btst  0xff, %o0                                
40013894:	02 80 00 0b 	be  400138c0 <rtems_rfs_inode_delete+0x40>     <== ALWAYS TAKEN
40013898:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",    
4001389c:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400138a0:	02 80 00 13 	be  400138ec <rtems_rfs_inode_delete+0x6c>     <== NOT EXECUTED
400138a4:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
400138a8:	15 10 00 db 	sethi  %hi(0x40036c00), %o2                    <== NOT EXECUTED
400138ac:	94 12 a3 50 	or  %o2, 0x350, %o2	! 40036f50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
400138b0:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
400138b4:	40 00 46 32 	call  4002517c <printf>                        <== NOT EXECUTED
400138b8:	90 12 20 48 	or  %o0, 0x48, %o0	! 40037048 <_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))                             
400138bc:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         <== NOT EXECUTED
400138c0:	80 a0 60 00 	cmp  %g1, 0                                    
400138c4:	02 80 00 08 	be  400138e4 <rtems_rfs_inode_delete+0x64>     <== NEVER TAKEN
400138c8:	90 10 20 00 	clr  %o0                                       
    rtems_rfs_block_map map;                                          
                                                                      
    /*                                                                
     * Free the ino number.                                           
     */                                                               
    rc = rtems_rfs_inode_free (fs, handle->ino);                      
400138cc:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           
400138d0:	7f ff ff 1c 	call  40013540 <rtems_rfs_inode_free>          
400138d4:	90 10 00 18 	mov  %i0, %o0                                  
    if (rc > 0)                                                       
400138d8:	80 a2 20 00 	cmp  %o0, 0                                    
400138dc:	24 80 00 07 	ble,a   400138f8 <rtems_rfs_inode_delete+0x78> <== ALWAYS TAKEN
400138e0:	90 10 00 18 	mov  %i0, %o0                                  
      handle->loads = 0;                                              
      handle->node = NULL;                                            
    }                                                                 
  }                                                                   
  return rc;                                                          
}                                                                     
400138e4:	81 c7 e0 08 	ret                                            
400138e8:	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",    
400138ec:	15 10 00 d5 	sethi  %hi(0x40035400), %o2                    <== NOT EXECUTED
400138f0:	10 bf ff f0 	b  400138b0 <rtems_rfs_inode_delete+0x30>      <== NOT EXECUTED
400138f4:	94 12 a0 60 	or  %o2, 0x60, %o2	! 40035460 <Callbacks.6428+0x218><== NOT EXECUTED
      return rc;                                                      
                                                                      
    /*                                                                
     * Free the blocks the inode may have attached.                   
     */                                                               
    rc = rtems_rfs_block_map_open (fs, handle, &map);                 
400138f8:	92 10 00 19 	mov  %i1, %o1                                  
400138fc:	40 00 23 c5 	call  4001c810 <rtems_rfs_block_map_open>      
40013900:	94 07 bf b0 	add  %fp, -80, %o2                             
    if (rc == 0)                                                      
40013904:	80 a2 20 00 	cmp  %o0, 0                                    
40013908:	12 bf ff f7 	bne  400138e4 <rtems_rfs_inode_delete+0x64>    <== NEVER TAKEN
4001390c:	92 07 bf b0 	add  %fp, -80, %o1                             
    {                                                                 
      int rrc;                                                        
      rrc = rtems_rfs_block_map_free_all (fs, &map);                  
40013910:	40 00 26 d7 	call  4001d46c <rtems_rfs_block_map_free_all>  
40013914:	90 10 00 18 	mov  %i0, %o0                                  
      rc = rtems_rfs_block_map_close (fs, &map);                      
40013918:	92 07 bf b0 	add  %fp, -80, %o1                             
4001391c:	40 00 24 1e 	call  4001c994 <rtems_rfs_block_map_close>     
40013920:	90 10 00 18 	mov  %i0, %o0                                  
      if (rc > 0)                                                     
        rrc = rc;                                                     
      memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);              
40013924:	d0 06 60 0c 	ld  [ %i1 + 0xc ], %o0                         
40013928:	92 10 20 ff 	mov  0xff, %o1                                 
4001392c:	40 00 45 96 	call  40024f84 <memset>                        
40013930:	94 10 20 38 	mov  0x38, %o2                                 
      rtems_rfs_buffer_mark_dirty (&handle->buffer);                  
40013934:	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);     
40013938:	90 10 00 18 	mov  %i0, %o0                                  
4001393c:	92 06 60 10 	add  %i1, 0x10, %o1                            
40013940:	40 00 27 3e 	call  4001d638 <rtems_rfs_buffer_handle_release>
40013944:	c2 2e 60 10 	stb  %g1, [ %i1 + 0x10 ]                       
      handle->loads = 0;                                              
40013948:	c0 26 60 24 	clr  [ %i1 + 0x24 ]                            
      handle->node = NULL;                                            
4001394c:	10 bf ff e6 	b  400138e4 <rtems_rfs_inode_delete+0x64>      
40013950:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
                                                                      

40013554 <rtems_rfs_inode_load>: } int rtems_rfs_inode_load (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle) {
40013554:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))                   
40013558:	90 10 20 00 	clr  %o0                                       
4001355c:	40 00 06 d2 	call  400150a4 <rtems_rfs_trace>               
40013560:	13 00 04 00 	sethi  %hi(0x100000), %o1                      
40013564:	80 8a 20 ff 	btst  0xff, %o0                                
40013568:	02 80 00 0c 	be  40013598 <rtems_rfs_inode_load+0x44>       <== ALWAYS TAKEN
4001356c:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
40013570:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
40013574:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40013578:	02 80 00 11 	be  400135bc <rtems_rfs_inode_load+0x68>       <== NOT EXECUTED
4001357c:	d4 06 60 24 	ld  [ %i1 + 0x24 ], %o2                        <== NOT EXECUTED
40013580:	17 10 00 db 	sethi  %hi(0x40036c00), %o3                    <== NOT EXECUTED
40013584:	96 12 e3 50 	or  %o3, 0x350, %o3	! 40036f50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
40013588:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001358c:	40 00 46 fc 	call  4002517c <printf>                        <== NOT EXECUTED
40013590:	90 12 23 58 	or  %o0, 0x358, %o0	! 40036f58 <_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))                            
40013594:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         <== NOT EXECUTED
40013598:	80 a0 60 00 	cmp  %g1, 0                                    
4001359c:	22 80 00 0b 	be,a   400135c8 <rtems_rfs_inode_load+0x74>    
400135a0:	d4 06 60 1c 	ld  [ %i1 + 0x1c ], %o2                        
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
    handle->node += handle->offset;                                   
  }                                                                   
                                                                      
  handle->loads++;                                                    
400135a4:	c2 06 60 24 	ld  [ %i1 + 0x24 ], %g1                        
                                                                      
  return 0;                                                           
400135a8:	b0 10 20 00 	clr  %i0                                       
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
    handle->node += handle->offset;                                   
  }                                                                   
                                                                      
  handle->loads++;                                                    
400135ac:	82 00 60 01 	inc  %g1                                       
400135b0:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
                                                                      
  return 0;                                                           
}                                                                     
400135b4:	81 c7 e0 08 	ret                                            
400135b8:	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",
400135bc:	17 10 00 d5 	sethi  %hi(0x40035400), %o3                    <== NOT EXECUTED
400135c0:	10 bf ff f2 	b  40013588 <rtems_rfs_inode_load+0x34>        <== NOT EXECUTED
400135c4:	96 12 e0 60 	or  %o3, 0x60, %o3	! 40035460 <Callbacks.6428+0x218><== NOT EXECUTED
                                                                      
  if (!rtems_rfs_inode_is_loaded (handle))                            
  {                                                                   
    int rc;                                                           
                                                                      
    rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,         
400135c8:	90 10 00 18 	mov  %i0, %o0                                  
400135cc:	92 06 60 10 	add  %i1, 0x10, %o1                            
400135d0:	40 00 28 94 	call  4001d820 <rtems_rfs_buffer_handle_request>
400135d4:	96 10 20 01 	mov  1, %o3                                    
                                          handle->block, true);       
    if (rc > 0)                                                       
400135d8:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400135dc:	14 bf ff f6 	bg  400135b4 <rtems_rfs_inode_load+0x60>       <== NEVER TAKEN
400135e0:	01 00 00 00 	nop                                            
      return rc;                                                      
                                                                      
    handle->node = rtems_rfs_buffer_data (&handle->buffer);           
400135e4:	c4 06 60 18 	ld  [ %i1 + 0x18 ], %g2                        
    handle->node += handle->offset;                                   
400135e8:	c2 06 60 20 	ld  [ %i1 + 0x20 ], %g1                        
400135ec:	c4 00 a0 1c 	ld  [ %g2 + 0x1c ], %g2                        
400135f0:	87 28 60 03 	sll  %g1, 3, %g3                               
400135f4:	83 28 60 06 	sll  %g1, 6, %g1                               
400135f8:	82 20 40 03 	sub  %g1, %g3, %g1                             
400135fc:	82 00 80 01 	add  %g2, %g1, %g1                             
40013600:	10 bf ff e9 	b  400135a4 <rtems_rfs_inode_load+0x50>        
40013604:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
                                                                      

40013608 <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) {
40013608:	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))                   
4001360c:	90 10 20 00 	clr  %o0                                       
40013610:	40 00 06 a5 	call  400150a4 <rtems_rfs_trace>               
40013614:	13 00 01 00 	sethi  %hi(0x40000), %o1                       
40013618:	80 8a 20 ff 	btst  0xff, %o0                                
4001361c:	32 80 00 2d 	bne,a   400136d0 <rtems_rfs_inode_open+0xc8>   <== NEVER TAKEN
40013620:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
    printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);        
                                                                      
  if (ino == RTEMS_RFS_EMPTY_INO)                                     
40013624:	80 a6 60 00 	cmp  %i1, 0                                    
40013628:	12 80 00 04 	bne  40013638 <rtems_rfs_inode_open+0x30>      <== ALWAYS TAKEN
4001362c:	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;                                                          
}                                                                     
40013630:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013634:	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))          
40013638:	c4 06 20 14 	ld  [ %i0 + 0x14 ], %g2                        
4001363c:	ba 06 7f ff 	add  %i1, -1, %i5                              
40013640:	80 a7 40 02 	cmp  %i5, %g2                                  
40013644:	18 bf ff fb 	bgu  40013630 <rtems_rfs_inode_open+0x28>      <== NEVER TAKEN
40013648:	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;                                    
4001364c:	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;                                                  
40013650:	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;                                    
40013654:	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;                                                
40013658:	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;                                    
4001365c:	40 00 78 5e 	call  400317d4 <.urem>                         
40013660:	c0 26 a0 24 	clr  [ %i2 + 0x24 ]                            
  index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
40013664:	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;                                    
40013668:	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;                       
4001366c:	40 00 78 5a 	call  400317d4 <.urem>                         
40013670:	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;                                    
40013674:	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;                       
40013678:	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;                                    
4001367c:	7f ff bc 09 	call  400026a0 <.udiv>                         
40013680:	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); 
40013684:	c4 06 20 20 	ld  [ %i0 + 0x20 ], %g2                        
40013688:	87 2a 20 04 	sll  %o0, 4, %g3                               
4001368c:	83 2a 20 06 	sll  %o0, 6, %g1                               
40013690:	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;
40013694:	fa 00 80 01 	ld  [ %g2 + %g1 ], %i5                         
40013698:	90 10 00 19 	mov  %i1, %o0                                  
4001369c:	ba 07 60 02 	add  %i5, 2, %i5                               
400136a0:	7f ff bc 00 	call  400026a0 <.udiv>                         
400136a4:	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;                                              
400136a8:	c0 2e a0 10 	clrb  [ %i2 + 0x10 ]                           
                                                                      
  handle->offset = gino % fs->inodes_per_block;                       
  handle->block  = rtems_rfs_group_block (&fs->groups[group], index); 
400136ac:	90 07 40 08 	add  %i5, %o0, %o0                             
  handle->bnum  = 0;                                                  
400136b0:	c0 26 a0 14 	clr  [ %i2 + 0x14 ]                            
400136b4:	d0 26 a0 1c 	st  %o0, [ %i2 + 0x1c ]                        
  handle->buffer = NULL;                                              
400136b8:	c0 26 a0 18 	clr  [ %i2 + 0x18 ]                            
                                                                      
  rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);            
  if ((rc == 0) && load)                                              
400136bc:	80 a6 e0 00 	cmp  %i3, 0                                    
400136c0:	02 bf ff dc 	be  40013630 <rtems_rfs_inode_open+0x28>       <== NEVER TAKEN
400136c4:	82 10 20 00 	clr  %g1                                       
    rc = rtems_rfs_inode_load (fs, handle);                           
400136c8:	7f ff ff a3 	call  40013554 <rtems_rfs_inode_load>          
400136cc:	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);        
400136d0:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
400136d4:	40 00 46 aa 	call  4002517c <printf>                        <== NOT EXECUTED
400136d8:	90 12 23 90 	or  %o0, 0x390, %o0	! 40036f90 <_CPU_Trap_slot_template+0xaa8><== NOT EXECUTED
                                                                      
  if (ino == RTEMS_RFS_EMPTY_INO)                                     
400136dc:	10 bf ff d3 	b  40013628 <rtems_rfs_inode_open+0x20>        <== NOT EXECUTED
400136e0:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
                                                                      

40013954 <rtems_rfs_inode_time_stamp_now>: int rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle, bool atime, bool mtime) {
40013954:	9d e3 bf a0 	save  %sp, -96, %sp                            
  time_t now;                                                         
  if (!rtems_rfs_inode_is_loaded (handle))                            
40013958:	c2 06 20 0c 	ld  [ %i0 + 0xc ], %g1                         
                                                                      
int                                                                   
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,       
                                bool                    atime,        
                                bool                    mtime)        
{                                                                     
4001395c:	ba 10 00 18 	mov  %i0, %i5                                  
  time_t now;                                                         
  if (!rtems_rfs_inode_is_loaded (handle))                            
40013960:	80 a0 60 00 	cmp  %g1, 0                                    
40013964:	02 80 00 23 	be  400139f0 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
40013968:	b0 10 20 06 	mov  6, %i0                                    
    return ENXIO;                                                     
  now = time (NULL);                                                  
4001396c:	40 00 56 48 	call  4002928c <time>                          
40013970:	90 10 20 00 	clr  %o0                                       
  if (atime)                                                          
40013974:	80 a6 60 00 	cmp  %i1, 0                                    
40013978:	02 80 00 0f 	be  400139b4 <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
4001397c:	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);                  
40013980:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
40013984:	85 32 20 18 	srl  %o0, 0x18, %g2                            
40013988:	c4 28 60 10 	stb  %g2, [ %g1 + 0x10 ]                       
4001398c:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
40013990:	85 32 20 10 	srl  %o0, 0x10, %g2                            
40013994:	c4 28 60 11 	stb  %g2, [ %g1 + 0x11 ]                       
40013998:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
4001399c:	85 32 20 08 	srl  %o0, 8, %g2                               
400139a0:	c4 28 60 12 	stb  %g2, [ %g1 + 0x12 ]                       
400139a4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400139a8:	d0 28 60 13 	stb  %o0, [ %g1 + 0x13 ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
400139ac:	82 10 20 01 	mov  1, %g1                                    
400139b0:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
    rtems_rfs_inode_set_atime (handle, now);                          
  if (mtime)                                                          
400139b4:	02 80 00 0f 	be  400139f0 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
400139b8:	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);                  
400139bc:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400139c0:	85 32 20 18 	srl  %o0, 0x18, %g2                            
400139c4:	c4 28 60 14 	stb  %g2, [ %g1 + 0x14 ]                       
400139c8:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400139cc:	85 32 20 10 	srl  %o0, 0x10, %g2                            
400139d0:	c4 28 60 15 	stb  %g2, [ %g1 + 0x15 ]                       
400139d4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400139d8:	85 32 20 08 	srl  %o0, 8, %g2                               
400139dc:	c4 28 60 16 	stb  %g2, [ %g1 + 0x16 ]                       
400139e0:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400139e4:	d0 28 60 17 	stb  %o0, [ %g1 + 0x17 ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
400139e8:	82 10 20 01 	mov  1, %g1                                    
400139ec:	c2 2f 60 10 	stb  %g1, [ %i5 + 0x10 ]                       
    rtems_rfs_inode_set_mtime (handle, now);                          
  return 0;                                                           
}                                                                     
400139f0:	81 c7 e0 08 	ret                                            
400139f4:	81 e8 00 00 	restore                                        
                                                                      

400136e4 <rtems_rfs_inode_unload>: int rtems_rfs_inode_unload (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* handle, bool update_ctime) {
400136e4:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int rc = 0;                                                         
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))                 
400136e8:	90 10 20 00 	clr  %o0                                       
400136ec:	40 00 06 6e 	call  400150a4 <rtems_rfs_trace>               
400136f0:	13 00 08 00 	sethi  %hi(0x200000), %o1                      
400136f4:	80 8a 20 ff 	btst  0xff, %o0                                
400136f8:	02 80 00 0c 	be  40013728 <rtems_rfs_inode_unload+0x44>     <== ALWAYS TAKEN
400136fc:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
    printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
40013700:	d2 06 60 08 	ld  [ %i1 + 8 ], %o1                           <== NOT EXECUTED
40013704:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40013708:	02 80 00 25 	be  4001379c <rtems_rfs_inode_unload+0xb8>     <== NOT EXECUTED
4001370c:	d4 06 60 24 	ld  [ %i1 + 0x24 ], %o2                        <== NOT EXECUTED
40013710:	17 10 00 db 	sethi  %hi(0x40036c00), %o3                    <== NOT EXECUTED
40013714:	96 12 e3 50 	or  %o3, 0x350, %o3	! 40036f50 <_CPU_Trap_slot_template+0xa68><== NOT EXECUTED
40013718:	11 10 00 db 	sethi  %hi(0x40036c00), %o0                    <== NOT EXECUTED
4001371c:	40 00 46 98 	call  4002517c <printf>                        <== NOT EXECUTED
40013720:	90 12 23 b8 	or  %o0, 0x3b8, %o0	! 40036fb8 <_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))                             
40013724:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         <== NOT EXECUTED
40013728:	80 a0 60 00 	cmp  %g1, 0                                    
4001372c:	22 80 00 0d 	be,a   40013760 <rtems_rfs_inode_unload+0x7c>  
40013730:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (handle->loads == 0)                                           
40013734:	c4 06 60 24 	ld  [ %i1 + 0x24 ], %g2                        
40013738:	80 a0 a0 00 	cmp  %g2, 0                                    
4001373c:	12 80 00 04 	bne  4001374c <rtems_rfs_inode_unload+0x68>    <== ALWAYS TAKEN
40013740:	90 10 20 05 	mov  5, %o0                                    
      handle->node = NULL;                                            
    }                                                                 
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
40013744:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40013748:	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--;                                                  
4001374c:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
    if (handle->loads == 0)                                           
40013750:	80 a0 a0 00 	cmp  %g2, 0                                    
40013754:	02 80 00 05 	be  40013768 <rtems_rfs_inode_unload+0x84>     
40013758:	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;                                                         
4001375c:	90 10 20 00 	clr  %o0                                       
      handle->node = NULL;                                            
    }                                                                 
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
40013760:	81 c7 e0 08 	ret                                            
40013764:	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)   
40013768:	c2 0e 60 10 	ldub  [ %i1 + 0x10 ], %g1                      
4001376c:	80 a0 60 00 	cmp  %g1, 0                                    
40013770:	02 80 00 06 	be  40013788 <rtems_rfs_inode_unload+0xa4>     
40013774:	90 10 00 18 	mov  %i0, %o0                                  
40013778:	80 a6 a0 00 	cmp  %i2, 0                                    
4001377c:	12 80 00 0b 	bne  400137a8 <rtems_rfs_inode_unload+0xc4>    <== ALWAYS TAKEN
40013780:	01 00 00 00 	nop                                            
        rtems_rfs_inode_set_ctime (handle, time (NULL));              
      rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);     
40013784:	90 10 00 18 	mov  %i0, %o0                                  
40013788:	40 00 27 ac 	call  4001d638 <rtems_rfs_buffer_handle_release>
4001378c:	92 06 60 10 	add  %i1, 0x10, %o1                            
      handle->node = NULL;                                            
40013790:	c0 26 60 0c 	clr  [ %i1 + 0xc ]                             
    }                                                                 
  }                                                                   
                                                                      
  return rc;                                                          
}                                                                     
40013794:	81 c7 e0 08 	ret                                            
40013798:	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",
4001379c:	17 10 00 d5 	sethi  %hi(0x40035400), %o3                    <== NOT EXECUTED
400137a0:	10 bf ff de 	b  40013718 <rtems_rfs_inode_unload+0x34>      <== NOT EXECUTED
400137a4:	96 12 e0 60 	or  %o3, 0x60, %o3	! 40035460 <Callbacks.6428+0x218><== 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));              
400137a8:	40 00 56 b9 	call  4002928c <time>                          
400137ac:	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);                  
400137b0:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400137b4:	85 32 20 18 	srl  %o0, 0x18, %g2                            
400137b8:	c4 28 60 18 	stb  %g2, [ %g1 + 0x18 ]                       
400137bc:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400137c0:	85 32 20 10 	srl  %o0, 0x10, %g2                            
400137c4:	c4 28 60 19 	stb  %g2, [ %g1 + 0x19 ]                       
400137c8:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400137cc:	85 32 20 08 	srl  %o0, 8, %g2                               
400137d0:	c4 28 60 1a 	stb  %g2, [ %g1 + 0x1a ]                       
400137d4:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
400137d8:	d0 28 60 1b 	stb  %o0, [ %g1 + 0x1b ]                       
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
400137dc:	82 10 20 01 	mov  1, %g1                                    
400137e0:	10 bf ff e9 	b  40013784 <rtems_rfs_inode_unload+0xa0>      
400137e4:	c2 2e 60 10 	stb  %g1, [ %i1 + 0x10 ]                       
                                                                      

40020d98 <rtems_rfs_link>: const char* name, int length, rtems_rfs_ino parent, rtems_rfs_ino target, bool link_dir) {
40020d98:	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))                         
40020d9c:	90 10 20 00 	clr  %o0                                       
40020da0:	13 00 40 00 	sethi  %hi(0x1000000), %o1                     
40020da4:	7f ff d0 c0 	call  400150a4 <rtems_rfs_trace>               
40020da8:	a2 10 00 18 	mov  %i0, %l1                                  
40020dac:	80 8a 20 ff 	btst  0xff, %o0                                
40020db0:	12 80 00 52 	bne  40020ef8 <rtems_rfs_link+0x160>           <== NEVER TAKEN
40020db4:	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);        
40020db8:	90 10 00 11 	mov  %l1, %o0                                  
40020dbc:	92 10 00 1c 	mov  %i4, %o1                                  
40020dc0:	94 07 bf d8 	add  %fp, -40, %o2                             
40020dc4:	7f ff ca 11 	call  40013608 <rtems_rfs_inode_open>          
40020dc8:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40020dcc:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40020dd0:	12 80 00 3d 	bne  40020ec4 <rtems_rfs_link+0x12c>           <== NEVER TAKEN
40020dd4:	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)))
40020dd8:	12 80 00 0b 	bne  40020e04 <rtems_rfs_link+0x6c>            <== NEVER TAKEN
40020ddc:	90 10 00 11 	mov  %l1, %o0                                  
40020de0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
40020de4:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
40020de8:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
40020dec:	85 28 a0 08 	sll  %g2, 8, %g2                               
40020df0:	84 08 80 01 	and  %g2, %g1, %g2                             
40020df4:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
40020df8:	80 a0 80 01 	cmp  %g2, %g1                                  
40020dfc:	02 80 00 55 	be  40020f50 <rtems_rfs_link+0x1b8>            <== NEVER TAKEN
40020e00:	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);        
40020e04:	92 10 00 1b 	mov  %i3, %o1                                  
40020e08:	94 07 bf b0 	add  %fp, -80, %o2                             
40020e0c:	7f ff c9 ff 	call  40013608 <rtems_rfs_inode_open>          
40020e10:	96 10 20 01 	mov  1, %o3                                    
40020e14:	b0 10 00 08 	mov  %o0, %i0                                  
  if (rc)                                                             
40020e18:	80 a6 20 00 	cmp  %i0, 0                                    
40020e1c:	12 80 00 27 	bne  40020eb8 <rtems_rfs_link+0x120>           <== NEVER TAKEN
40020e20:	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);
40020e24:	92 07 bf b0 	add  %fp, -80, %o1                             
40020e28:	94 10 00 19 	mov  %i1, %o2                                  
40020e2c:	96 10 00 1a 	mov  %i2, %o3                                  
40020e30:	7f ff f5 bd 	call  4001e524 <rtems_rfs_dir_add_entry>       
40020e34:	98 10 00 1c 	mov  %i4, %o4                                  
  if (rc > 0)                                                         
40020e38:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40020e3c:	14 80 00 42 	bg  40020f44 <rtems_rfs_link+0x1ac>            <== NEVER TAKEN
40020e40:	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);                  
40020e44:	c6 08 60 01 	ldub  [ %g1 + 1 ], %g3                         
40020e48:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
40020e4c:	85 28 a0 08 	sll  %g2, 8, %g2                               
40020e50:	84 10 80 03 	or  %g2, %g3, %g2                              
  if (links == 0xffff)                                                
40020e54:	07 3f ff c0 	sethi  %hi(0xffff0000), %g3                    
40020e58:	89 28 a0 10 	sll  %g2, 0x10, %g4                            
40020e5c:	80 a1 00 03 	cmp  %g4, %g3                                  
40020e60:	22 80 00 40 	be,a   40020f60 <rtems_rfs_link+0x1c8>         <== NEVER TAKEN
40020e64:	84 10 20 01 	mov  1, %g2                                    <== NOT EXECUTED
40020e68:	84 00 a0 01 	inc  %g2                                       
40020e6c:	87 28 a0 10 	sll  %g2, 0x10, %g3                            
40020e70:	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);                  
40020e74:	c6 28 40 00 	stb  %g3, [ %g1 ]                              
40020e78:	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);    
40020e7c:	92 10 20 01 	mov  1, %o1                                    
40020e80:	c4 28 60 01 	stb  %g2, [ %g1 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40020e84:	82 10 20 01 	mov  1, %g1                                    
40020e88:	90 07 bf b0 	add  %fp, -80, %o0                             
40020e8c:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
40020e90:	7f ff ca b1 	call  40013954 <rtems_rfs_inode_time_stamp_now>
40020e94:	94 10 20 01 	mov  1, %o2                                    
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &parent_inode);                        
40020e98:	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);    
40020e9c:	b0 10 00 08 	mov  %o0, %i0                                  
  if (rc > 0)                                                         
40020ea0:	80 a6 20 00 	cmp  %i0, 0                                    
40020ea4:	04 80 00 0a 	ble  40020ecc <rtems_rfs_link+0x134>           <== ALWAYS TAKEN
40020ea8:	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);                        
40020eac:	7f ff ca 4f 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020eb0:	01 00 00 00 	nop                                            <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &target_inode);                        
40020eb4:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
40020eb8:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40020ebc:	7f ff ca 4b 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020ec0:	01 00 00 00 	nop                                            <== NOT EXECUTED
40020ec4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020ec8:	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);                     
40020ecc:	7f ff ca 47 	call  400137e8 <rtems_rfs_inode_close>         
40020ed0:	01 00 00 00 	nop                                            
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
40020ed4:	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);                     
40020ed8:	b0 10 00 08 	mov  %o0, %i0                                  
  if (rc > 0)                                                         
40020edc:	80 a6 20 00 	cmp  %i0, 0                                    
40020ee0:	14 bf ff f7 	bg  40020ebc <rtems_rfs_link+0x124>            <== NEVER TAKEN
40020ee4:	90 10 00 11 	mov  %l1, %o0                                  
  {                                                                   
    rtems_rfs_inode_close (fs, &target_inode);                        
    return rc;                                                        
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &target_inode);                     
40020ee8:	7f ff ca 40 	call  400137e8 <rtems_rfs_inode_close>         
40020eec:	01 00 00 00 	nop                                            
                                                                      
  return rc;                                                          
}                                                                     
40020ef0:	81 c7 e0 08 	ret                                            
40020ef4:	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);      
40020ef8:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40020efc:	40 00 10 a0 	call  4002517c <printf>                        <== NOT EXECUTED
40020f00:	90 12 21 f8 	or  %o0, 0x1f8, %o0	! 400391f8 <CSWTCH.2+0x1408><== NOT EXECUTED
40020f04:	a0 10 00 19 	mov  %i1, %l0                                  <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
40020f08:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
40020f0c:	04 80 00 08 	ble  40020f2c <rtems_rfs_link+0x194>           <== NOT EXECUTED
40020f10:	b0 06 40 1a 	add  %i1, %i2, %i0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
40020f14:	d0 4c 00 00 	ldsb  [ %l0 ], %o0                             <== NOT EXECUTED
40020f18:	40 00 11 03 	call  40025324 <putchar>                       <== NOT EXECUTED
40020f1c:	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++)                                      
40020f20:	80 a4 00 18 	cmp  %l0, %i0                                  <== NOT EXECUTED
40020f24:	32 bf ff fd 	bne,a   40020f18 <rtems_rfs_link+0x180>        <== NOT EXECUTED
40020f28:	d0 4c 00 00 	ldsb  [ %l0 ], %o0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf ("(%" PRIu32 ")\n", target);                               
40020f2c:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40020f30:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40020f34:	40 00 10 92 	call  4002517c <printf>                        <== NOT EXECUTED
40020f38:	90 12 22 20 	or  %o0, 0x220, %o0	! 40039220 <CSWTCH.2+0x1430><== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
40020f3c:	10 bf ff a0 	b  40020dbc <rtems_rfs_link+0x24>              <== NOT EXECUTED
40020f40:	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);                        
40020f44:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
40020f48:	10 bf ff d9 	b  40020eac <rtems_rfs_link+0x114>             <== NOT EXECUTED
40020f4c:	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);                        
40020f50:	7f ff ca 26 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020f54:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40020f58:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40020f5c:	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)                                                
40020f60:	10 bf ff c5 	b  40020e74 <rtems_rfs_link+0xdc>              <== NOT EXECUTED
40020f64:	86 10 20 00 	clr  %g3                                       <== NOT EXECUTED
                                                                      

400217cc <rtems_rfs_mutex_create>: RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL) #endif int rtems_rfs_mutex_create (rtems_rfs_mutex* mutex) {
400217cc:	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'), 
400217d0:	92 10 20 01 	mov  1, %o1                                    
400217d4:	98 10 00 18 	mov  %i0, %o4                                  
400217d8:	11 14 91 94 	sethi  %hi(0x52465000), %o0                    
400217dc:	94 10 20 54 	mov  0x54, %o2                                 
400217e0:	90 12 23 6d 	or  %o0, 0x36d, %o0                            
400217e4:	96 10 20 00 	clr  %o3                                       
400217e8:	7f ff b1 18 	call  4000dc48 <rtems_semaphore_create>        
400217ec:	b0 10 20 00 	clr  %i0                                       
                               1, RTEMS_RFS_MUTEX_ATTRIBS, 0,         
                               mutex);                                
  if (sc != RTEMS_SUCCESSFUL)                                         
400217f0:	80 a2 20 00 	cmp  %o0, 0                                    
400217f4:	02 80 00 0f 	be  40021830 <rtems_rfs_mutex_create+0x64>     <== ALWAYS TAKEN
400217f8:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400217fc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40021800:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021804:	7f ff ce 28 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021808:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
4002180c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021810:	02 80 00 08 	be  40021830 <rtems_rfs_mutex_create+0x64>     <== NOT EXECUTED
40021814:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: open failed: %s\n",                  
40021818:	7f ff dc 7e 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
4002181c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021820:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021824:	11 10 00 e5 	sethi  %hi(0x40039400), %o0                    <== NOT EXECUTED
40021828:	40 00 0e 55 	call  4002517c <printf>                        <== NOT EXECUTED
4002182c:	90 12 20 50 	or  %o0, 0x50, %o0	! 40039450 <CSWTCH.2+0x1660><== NOT EXECUTED
              rtems_status_text (sc));                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
40021830:	81 c7 e0 08 	ret                                            
40021834:	81 e8 00 00 	restore                                        
                                                                      

40021838 <rtems_rfs_mutex_destroy>: int rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex) {
40021838:	9d e3 bf a0 	save  %sp, -96, %sp                            
#if __rtems__                                                         
  rtems_status_code sc;                                               
  sc = rtems_semaphore_delete (*mutex);                               
4002183c:	d0 06 00 00 	ld  [ %i0 ], %o0                               
40021840:	7f ff b1 73 	call  4000de0c <rtems_semaphore_delete>        
40021844:	b0 10 20 00 	clr  %i0                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
40021848:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4002184c:	02 80 00 0e 	be  40021884 <rtems_rfs_mutex_destroy+0x4c>    <== ALWAYS TAKEN
40021850:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021854:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021858:	7f ff ce 13 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4002185c:	b0 10 20 05 	mov  5, %i0                                    <== NOT EXECUTED
40021860:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021864:	02 80 00 08 	be  40021884 <rtems_rfs_mutex_destroy+0x4c>    <== NOT EXECUTED
40021868:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: close failed: %s\n",                 
4002186c:	7f ff dc 69 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021870:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021874:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021878:	11 10 00 e5 	sethi  %hi(0x40039400), %o0                    <== NOT EXECUTED
4002187c:	40 00 0e 40 	call  4002517c <printf>                        <== NOT EXECUTED
40021880:	90 12 20 78 	or  %o0, 0x78, %o0	! 40039478 <CSWTCH.2+0x1688><== NOT EXECUTED
              rtems_status_text (sc));                                
    return EIO;                                                       
  }                                                                   
#endif                                                                
  return 0;                                                           
}                                                                     
40021884:	81 c7 e0 08 	ret                                            
40021888:	81 e8 00 00 	restore                                        
                                                                      

4001d47c <rtems_rfs_release_chain>: static int rtems_rfs_release_chain (rtems_chain_control* chain, uint32_t* count, bool modified) {
4001d47c:	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))                
4001d480:	90 10 20 00 	clr  %o0                                       
4001d484:	92 10 20 80 	mov  0x80, %o1                                 
4001d488:	7f ff df 07 	call  400150a4 <rtems_rfs_trace>               
4001d48c:	ba 10 00 18 	mov  %i0, %i5                                  
4001d490:	80 8a 20 ff 	btst  0xff, %o0                                
4001d494:	32 80 00 1c 	bne,a   4001d504 <rtems_rfs_release_chain+0x88><== NEVER TAKEN
4001d498:	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))                                       
4001d49c:	b0 10 20 00 	clr  %i0                                       
4001d4a0:	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))                               
4001d4a4:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001d4a8:	80 a0 40 1c 	cmp  %g1, %i4                                  
4001d4ac:	02 80 00 14 	be  4001d4fc <rtems_rfs_release_chain+0x80>    
4001d4b0:	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 );                                     
4001d4b4:	7f ff c5 69 	call  4000ea58 <_Chain_Get>                    
4001d4b8:	01 00 00 00 	nop                                            
  {                                                                   
    buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);             
    (*count)--;                                                       
4001d4bc:	c2 06 40 00 	ld  [ %i1 ], %g1                               
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
4001d4c0:	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)--;                                                       
4001d4c4:	82 00 7f ff 	add  %g1, -1, %g1                              
4001d4c8:	c2 26 40 00 	st  %g1, [ %i1 ]                               
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
4001d4cc:	40 00 18 7b 	call  400236b8 <rtems_rfs_buffer_bdbuf_release>
4001d4d0:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
    if ((rc > 0) && (rrc == 0))                                       
4001d4d4:	80 a2 20 00 	cmp  %o0, 0                                    
4001d4d8:	04 bf ff f4 	ble  4001d4a8 <rtems_rfs_release_chain+0x2c>   <== ALWAYS TAKEN
4001d4dc:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4001d4e0:	80 a6 20 00 	cmp  %i0, 0                                    <== NOT EXECUTED
4001d4e4:	12 bf ff f1 	bne  4001d4a8 <rtems_rfs_release_chain+0x2c>   <== NOT EXECUTED
4001d4e8:	01 00 00 00 	nop                                            <== NOT EXECUTED
4001d4ec:	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))                               
4001d4f0:	80 a0 40 1c 	cmp  %g1, %i4                                  <== NOT EXECUTED
4001d4f4:	12 bf ff f0 	bne  4001d4b4 <rtems_rfs_release_chain+0x38>   <== NOT EXECUTED
4001d4f8:	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;                                                         
}                                                                     
4001d4fc:	81 c7 e0 08 	ret                                            
4001d500:	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); 
4001d504:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001d508:	40 00 1f 1d 	call  4002517c <printf>                        <== NOT EXECUTED
4001d50c:	90 12 23 00 	or  %o0, 0x300, %o0	! 40037f00 <CSWTCH.2+0x110><== NOT EXECUTED
    (*count)--;                                                       
                                                                      
    buffer->user = (void*) 0;                                         
                                                                      
    rc = rtems_rfs_buffer_io_release (buffer, modified);              
    if ((rc > 0) && (rrc == 0))                                       
4001d510:	10 bf ff e4 	b  4001d4a0 <rtems_rfs_release_chain+0x24>     <== NOT EXECUTED
4001d514:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                                                                      

400142d0 <rtems_rfs_rtems_chown>: static int rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc, uid_t owner, gid_t group) {
400142d0:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
400142d4:	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);                  
400142d8:	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);  
400142dc:	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);                  
400142e0:	94 07 bf d8 	add  %fp, -40, %o2                             
400142e4:	90 10 00 1c 	mov  %i4, %o0                                  
400142e8:	7f ff fc c8 	call  40013608 <rtems_rfs_inode_open>          
400142ec:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
400142f0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400142f4:	04 80 00 07 	ble  40014310 <rtems_rfs_rtems_chown+0x40>     <== ALWAYS TAKEN
400142f8:	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);        
400142fc:	40 00 3e 0f 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014300:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
40014304:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40014308:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001430c:	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();                                                    
40014310:	40 00 12 95 	call  40018d64 <geteuid>                       
40014314:	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;          
40014318:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))        
4001431c:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40014320:	c4 08 60 06 	ldub  [ %g1 + 6 ], %g2                         
40014324:	c6 08 60 07 	ldub  [ %g1 + 7 ], %g3                         
40014328:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001432c:	84 10 80 03 	or  %g2, %g3, %g2                              
40014330:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40014334:	80 a0 80 08 	cmp  %g2, %o0                                  
40014338:	02 80 00 05 	be  4001434c <rtems_rfs_rtems_chown+0x7c>      <== ALWAYS TAKEN
4001433c:	89 32 20 10 	srl  %o0, 0x10, %g4                            
40014340:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40014344:	12 80 00 19 	bne  400143a8 <rtems_rfs_rtems_chown+0xd8>     <== NOT EXECUTED
40014348:	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);
4001434c:	b5 2e a0 10 	sll  %i2, 0x10, %i2                            
40014350:	b4 16 80 19 	or  %i2, %i1, %i2                              
40014354:	85 36 a0 18 	srl  %i2, 0x18, %g2                            
40014358:	c4 28 60 04 	stb  %g2, [ %g1 + 4 ]                          
4001435c:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
40014360:	85 36 a0 10 	srl  %i2, 0x10, %g2                            
40014364:	c4 28 60 05 	stb  %g2, [ %g1 + 5 ]                          
40014368:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
4001436c:	b5 36 a0 08 	srl  %i2, 8, %i2                               
40014370:	f4 28 60 06 	stb  %i2, [ %g1 + 6 ]                          
40014374:	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);                            
40014378:	90 10 00 1c 	mov  %i4, %o0                                  
4001437c:	f2 28 60 07 	stb  %i1, [ %g1 + 7 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40014380:	82 10 20 01 	mov  1, %g1                                    
40014384:	92 07 bf d8 	add  %fp, -40, %o1                             
40014388:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
4001438c:	7f ff fd 17 	call  400137e8 <rtems_rfs_inode_close>         
40014390:	b0 10 20 00 	clr  %i0                                       
  if (rc)                                                             
40014394:	80 a2 20 00 	cmp  %o0, 0                                    
40014398:	12 bf ff d9 	bne  400142fc <rtems_rfs_rtems_chown+0x2c>     <== NEVER TAKEN
4001439c:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("chown: closing inode", rc);        
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
400143a0:	81 c7 e0 08 	ret                                            
400143a4:	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);                               
400143a8:	7f ff fd 10 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
400143ac:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("chown: not able", EPERM);          
400143b0:	40 00 3d e2 	call  40023b38 <__errno>                       <== NOT EXECUTED
400143b4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400143b8:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
400143bc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400143c0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400143c4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400218d0 <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);
400218d0:	d2 02 20 2c 	ld  [ %o0 + 0x2c ], %o1                        <== NOT EXECUTED
400218d4:	d4 02 20 30 	ld  [ %o0 + 0x30 ], %o2                        <== NOT EXECUTED
400218d8:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400218dc:	40 00 05 24 	call  40022d6c <rtems_deviceio_close>          <== NOT EXECUTED
400218e0:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

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

40021894 <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);
40021894:	d6 02 20 2c 	ld  [ %o0 + 0x2c ], %o3                        <== NOT EXECUTED
40021898:	d8 02 20 30 	ld  [ %o0 + 0x30 ], %o4                        <== NOT EXECUTED
4002189c:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400218a0:	40 00 05 75 	call  40022e74 <rtems_deviceio_control>        <== NOT EXECUTED
400218a4:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

400218e4 <rtems_rfs_rtems_device_open>: static int rtems_rfs_rtems_device_open ( rtems_libio_t *iop, const char *pathname, int oflag, mode_t mode) {
400218e4:	9d e3 bf 78 	save  %sp, -136, %sp                           <== NOT EXECUTED
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
400218e8:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
  rtems_rfs_ino                 ino = rtems_rfs_rtems_get_iop_ino (iop);
400218ec:	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);
400218f0:	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);
400218f4:	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                       
};                                                                    
400218f8:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        <== NOT EXECUTED
400218fc:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
40021900:	7f ff b1 7a 	call  4000dee8 <rtems_semaphore_obtain>        <== NOT EXECUTED
40021904:	d0 00 40 00 	ld  [ %g1 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40021908:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
4002190c:	12 80 00 17 	bne  40021968 <rtems_rfs_rtems_device_open+0x84><== NOT EXECUTED
40021910:	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);                  
40021914:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021918:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
4002191c:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
40021920:	7f ff c7 3a 	call  40013608 <rtems_rfs_inode_open>          <== NOT EXECUTED
40021924:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc > 0)                                                         
40021928:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
4002192c:	04 80 00 23 	ble  400219b8 <rtems_rfs_rtems_device_open+0xd4><== NOT EXECUTED
40021930:	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);            
40021934:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40021938:	7f ff f1 04 	call  4001dd48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
4002193c:	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);            
40021940:	7f ff b1 b9 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
40021944:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40021948:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4002194c:	12 80 00 4c 	bne  40021a7c <rtems_rfs_rtems_device_open+0x198><== NOT EXECUTED
40021950:	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);  
40021954:	40 00 08 79 	call  40023b38 <__errno>                       <== NOT EXECUTED
40021958:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4002195c:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40021960:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40021964:	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))                      
40021968:	7f ff cd cf 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4002196c:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021970:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021974:	22 bf ff e9 	be,a   40021918 <rtems_rfs_rtems_device_open+0x34><== NOT EXECUTED
40021978:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
4002197c:	7f ff dc 25 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021980:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40021984:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021988:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4002198c:	40 00 0d fc 	call  4002517c <printf>                        <== NOT EXECUTED
40021990:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_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);                  
40021994:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021998:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
4002199c:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
400219a0:	7f ff c7 1a 	call  40013608 <rtems_rfs_inode_open>          <== NOT EXECUTED
400219a4:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc > 0)                                                         
400219a8:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
400219ac:	34 bf ff e3 	bg,a   40021938 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
400219b0:	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]);      
400219b4:	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);                            
400219b8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400219bc:	ec 08 60 1c 	ldub  [ %g1 + 0x1c ], %l6                      <== NOT EXECUTED
400219c0:	ea 08 60 1d 	ldub  [ %g1 + 0x1d ], %l5                      <== NOT EXECUTED
400219c4:	e6 08 60 1e 	ldub  [ %g1 + 0x1e ], %l3                      <== NOT EXECUTED
400219c8:	e8 08 60 1f 	ldub  [ %g1 + 0x1f ], %l4                      <== NOT EXECUTED
400219cc:	e4 08 60 20 	ldub  [ %g1 + 0x20 ], %l2                      <== NOT EXECUTED
400219d0:	e2 08 60 21 	ldub  [ %g1 + 0x21 ], %l1                      <== NOT EXECUTED
400219d4:	e0 08 60 22 	ldub  [ %g1 + 0x22 ], %l0                      <== NOT EXECUTED
400219d8:	ee 08 60 23 	ldub  [ %g1 + 0x23 ], %l7                      <== NOT EXECUTED
400219dc:	7f ff c7 83 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
400219e0:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
  if (rc > 0)                                                         
400219e4:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
400219e8:	34 bf ff d4 	bg,a   40021938 <rtems_rfs_rtems_device_open+0x54><== NOT EXECUTED
400219ec:	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);            
400219f0:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
400219f4:	7f ff f0 d5 	call  4001dd48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
400219f8:	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);            
400219fc:	7f ff b1 8a 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
40021a00:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40021a04:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40021a08:	12 80 00 2d 	bne  40021abc <rtems_rfs_rtems_device_open+0x1d8><== NOT EXECUTED
40021a0c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40021a10:	ad 2d a0 18 	sll  %l6, 0x18, %l6                            <== NOT EXECUTED
40021a14:	a8 0d 20 ff 	and  %l4, 0xff, %l4                            <== NOT EXECUTED
40021a18:	a5 2c a0 18 	sll  %l2, 0x18, %l2                            <== NOT EXECUTED
40021a1c:	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);
40021a20:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40021a24:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40021a28:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
40021a2c:	96 10 00 1b 	mov  %i3, %o3                                  <== NOT EXECUTED
40021a30:	aa 0d 60 ff 	and  %l5, 0xff, %l5                            <== NOT EXECUTED
40021a34:	a6 0c e0 ff 	and  %l3, 0xff, %l3                            <== NOT EXECUTED
40021a38:	ab 2d 60 10 	sll  %l5, 0x10, %l5                            <== NOT EXECUTED
40021a3c:	a7 2c e0 08 	sll  %l3, 8, %l3                               <== NOT EXECUTED
40021a40:	9a 15 80 15 	or  %l6, %l5, %o5                              <== NOT EXECUTED
40021a44:	a2 0c 60 ff 	and  %l1, 0xff, %l1                            <== NOT EXECUTED
40021a48:	9a 13 40 14 	or  %o5, %l4, %o5                              <== NOT EXECUTED
40021a4c:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            <== NOT EXECUTED
40021a50:	9a 13 40 13 	or  %o5, %l3, %o5                              <== NOT EXECUTED
40021a54:	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;                                                 
40021a58:	da 26 20 2c 	st  %o5, [ %i0 + 0x2c ]                        <== NOT EXECUTED
40021a5c:	98 13 00 17 	or  %o4, %l7, %o4                              <== NOT EXECUTED
40021a60:	a0 0c 20 ff 	and  %l0, 0xff, %l0                            <== NOT EXECUTED
40021a64:	a1 2c 20 08 	sll  %l0, 8, %l0                               <== NOT EXECUTED
40021a68:	98 13 00 10 	or  %o4, %l0, %o4                              <== NOT EXECUTED
  iop->data1 = (void *) minor;                                        
                                                                      
  return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
40021a6c:	40 00 04 b3 	call  40022d38 <rtems_deviceio_open>           <== NOT EXECUTED
40021a70:	d8 26 20 30 	st  %o4, [ %i0 + 0x30 ]                        <== NOT EXECUTED
}                                                                     
40021a74:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40021a78:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021a7c:	7f ff cd 8a 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021a80:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021a84:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021a88:	02 bf ff b3 	be  40021954 <rtems_rfs_rtems_device_open+0x70><== NOT EXECUTED
40021a8c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40021a90:	7f ff db e0 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021a94:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021a98:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021a9c:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40021aa0:	40 00 0d b7 	call  4002517c <printf>                        <== NOT EXECUTED
40021aa4:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_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);  
40021aa8:	40 00 08 24 	call  40023b38 <__errno>                       <== NOT EXECUTED
40021aac:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40021ab0:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40021ab4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40021ab8:	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))                      
40021abc:	7f ff cd 7a 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021ac0:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021ac4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021ac8:	22 bf ff d3 	be,a   40021a14 <rtems_rfs_rtems_device_open+0x130><== NOT EXECUTED
40021acc:	ad 2d a0 18 	sll  %l6, 0x18, %l6                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40021ad0:	7f ff db d0 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021ad4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021ad8:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021adc:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40021ae0:	40 00 0d a7 	call  4002517c <printf>                        <== NOT EXECUTED
40021ae4:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021ae8:	10 bf ff cb 	b  40021a14 <rtems_rfs_rtems_device_open+0x130><== NOT EXECUTED
40021aec:	ad 2d a0 18 	sll  %l6, 0x18, %l6                            <== NOT EXECUTED
                                                                      

400218bc <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);
400218bc:	d6 02 20 2c 	ld  [ %o0 + 0x2c ], %o3                        <== NOT EXECUTED
400218c0:	d8 02 20 30 	ld  [ %o0 + 0x30 ], %o4                        <== NOT EXECUTED
400218c4:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400218c8:	40 00 05 35 	call  40022d9c <rtems_deviceio_read>           <== NOT EXECUTED
400218cc:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

400218a8 <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);
400218a8:	d6 02 20 2c 	ld  [ %o0 + 0x2c ], %o3                        <== NOT EXECUTED
400218ac:	d8 02 20 30 	ld  [ %o0 + 0x30 ], %o4                        <== NOT EXECUTED
400218b0:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400218b4:	40 00 05 55 	call  40022e08 <rtems_deviceio_write>          <== NOT EXECUTED
400218b8:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

40021af8 <rtems_rfs_rtems_dir_open>: static int rtems_rfs_rtems_dir_open (rtems_libio_t* iop, const char* pathname, int oflag, mode_t mode) {
40021af8:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40021afc:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_iop_ino (iop);     
40021b00:	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);
40021b04:	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);
40021b08:	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                       
};                                                                    
40021b0c:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
40021b10:	94 10 20 00 	clr  %o2                                       
40021b14:	7f ff b0 f5 	call  4000dee8 <rtems_semaphore_obtain>        
40021b18:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021b1c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40021b20:	12 80 00 2d 	bne  40021bd4 <rtems_rfs_rtems_dir_open+0xdc>  <== NEVER TAKEN
40021b24:	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);                  
40021b28:	90 10 00 1d 	mov  %i5, %o0                                  
40021b2c:	92 10 00 1b 	mov  %i3, %o1                                  
40021b30:	94 07 bf d8 	add  %fp, -40, %o2                             
40021b34:	7f ff c6 b5 	call  40013608 <rtems_rfs_inode_open>          
40021b38:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40021b3c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40021b40:	32 80 00 39 	bne,a   40021c24 <rtems_rfs_rtems_dir_open+0x12c><== NEVER TAKEN
40021b44:	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);                    
40021b48:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
40021b4c:	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)))         
40021b50:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
40021b54:	85 28 a0 08 	sll  %g2, 8, %g2                               
40021b58:	84 08 80 01 	and  %g2, %g1, %g2                             
40021b5c:	03 00 00 10 	sethi  %hi(0x4000), %g1                        
40021b60:	80 a0 80 01 	cmp  %g2, %g1                                  
40021b64:	12 80 00 48 	bne  40021c84 <rtems_rfs_rtems_dir_open+0x18c> <== NEVER TAKEN
40021b68:	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);                                 
40021b6c:	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;                                                    
40021b70:	c0 26 20 08 	clr  [ %i0 + 8 ]                               
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
40021b74:	7f ff c7 1d 	call  400137e8 <rtems_rfs_inode_close>         
40021b78:	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);            
40021b7c:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        
  rtems_rfs_buffers_release (fs);                                     
40021b80:	7f ff f0 72 	call  4001dd48 <rtems_rfs_buffers_release>     
40021b84:	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);            
40021b88:	7f ff b1 27 	call  4000e024 <rtems_semaphore_release>       
40021b8c:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021b90:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021b94:	12 80 00 04 	bne  40021ba4 <rtems_rfs_rtems_dir_open+0xac>  <== NEVER TAKEN
40021b98:	90 10 20 00 	clr  %o0                                       
  rtems_rfs_rtems_unlock (fs);                                        
  return 0;                                                           
}                                                                     
40021b9c:	81 c7 e0 08 	ret                                            
40021ba0:	91 e8 20 00 	restore  %g0, 0, %o0                           
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021ba4:	7f ff cd 40 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021ba8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021bac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021bb0:	02 bf ff fb 	be  40021b9c <rtems_rfs_rtems_dir_open+0xa4>   <== NOT EXECUTED
40021bb4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40021bb8:	7f ff db 96 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021bbc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021bc0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021bc4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40021bc8:	40 00 0d 6d 	call  4002517c <printf>                        <== NOT EXECUTED
40021bcc:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021bd0:	30 bf ff f3 	b,a   40021b9c <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))                      
40021bd4:	7f ff cd 34 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021bd8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021bdc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021be0:	22 bf ff d3 	be,a   40021b2c <rtems_rfs_rtems_dir_open+0x34><== NOT EXECUTED
40021be4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40021be8:	7f ff db 8a 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021bec:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40021bf0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021bf4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40021bf8:	40 00 0d 61 	call  4002517c <printf>                        <== NOT EXECUTED
40021bfc:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_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);                  
40021c00:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021c04:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
40021c08:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
40021c0c:	7f ff c6 7f 	call  40013608 <rtems_rfs_inode_open>          <== NOT EXECUTED
40021c10:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc)                                                             
40021c14:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40021c18:	02 bf ff cd 	be  40021b4c <rtems_rfs_rtems_dir_open+0x54>   <== NOT EXECUTED
40021c1c:	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);            
40021c20:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40021c24:	7f ff f0 49 	call  4001dd48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40021c28:	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);            
40021c2c:	7f ff b0 fe 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
40021c30:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40021c34:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40021c38:	12 80 00 07 	bne  40021c54 <rtems_rfs_rtems_dir_open+0x15c> <== NOT EXECUTED
40021c3c:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("dir_open: opening inode", rc);     
40021c40:	40 00 07 be 	call  40023b38 <__errno>                       <== NOT EXECUTED
40021c44:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40021c48:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40021c4c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40021c50:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021c54:	7f ff cd 14 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021c58:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021c5c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021c60:	02 bf ff f8 	be  40021c40 <rtems_rfs_rtems_dir_open+0x148>  <== NOT EXECUTED
40021c64:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40021c68:	7f ff db 6a 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021c6c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021c70:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021c74:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40021c78:	40 00 0d 41 	call  4002517c <printf>                        <== NOT EXECUTED
40021c7c:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021c80:	30 bf ff f0 	b,a   40021c40 <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);                               
40021c84:	7f ff c6 d9 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40021c88:	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);            
40021c8c:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40021c90:	7f ff f0 2e 	call  4001dd48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40021c94:	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);            
40021c98:	7f ff b0 e3 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
40021c9c:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40021ca0:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40021ca4:	12 80 00 08 	bne  40021cc4 <rtems_rfs_rtems_dir_open+0x1cc> <== NOT EXECUTED
40021ca8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);      
40021cac:	40 00 07 a3 	call  40023b38 <__errno>                       <== NOT EXECUTED
40021cb0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40021cb4:	82 10 20 14 	mov  0x14, %g1                                 <== NOT EXECUTED
40021cb8:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40021cbc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40021cc0:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021cc4:	7f ff cc f8 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021cc8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021ccc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021cd0:	02 bf ff f7 	be  40021cac <rtems_rfs_rtems_dir_open+0x1b4>  <== NOT EXECUTED
40021cd4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40021cd8:	7f ff db 4e 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021cdc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021ce0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021ce4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40021ce8:	40 00 0d 25 	call  4002517c <printf>                        <== NOT EXECUTED
40021cec:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021cf0:	30 bf ff ef 	b,a   40021cac <rtems_rfs_rtems_dir_open+0x1b4><== NOT EXECUTED
                                                                      

40021cf4 <rtems_rfs_rtems_dir_read>: */ static ssize_t rtems_rfs_rtems_dir_read (rtems_libio_t* iop, void* buffer, size_t count) {
40021cf4:	9d e3 bf 70 	save  %sp, -144, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40021cf8:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        
  rtems_rfs_ino          ino = rtems_rfs_rtems_get_iop_ino (iop);     
40021cfc:	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);
40021d00:	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);
40021d04:	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                       
};                                                                    
40021d08:	c2 04 20 80 	ld  [ %l0 + 0x80 ], %g1                        
40021d0c:	94 10 20 00 	clr  %o2                                       
40021d10:	7f ff b0 76 	call  4000dee8 <rtems_semaphore_obtain>        
40021d14:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021d18:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021d1c:	12 80 00 41 	bne  40021e20 <rtems_rfs_rtems_dir_read+0x12c> <== NEVER TAKEN
40021d20:	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);                  
40021d24:	92 10 00 1c 	mov  %i4, %o1                                  
40021d28:	90 10 00 10 	mov  %l0, %o0                                  
40021d2c:	94 07 bf d8 	add  %fp, -40, %o2                             
40021d30:	7f ff c6 36 	call  40013608 <rtems_rfs_inode_open>          
40021d34:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40021d38:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40021d3c:	32 80 00 4d 	bne,a   40021e70 <rtems_rfs_rtems_dir_read+0x17c><== NEVER TAKEN
40021d40:	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);                            
40021d44:	90 10 00 1a 	mov  %i2, %o0                                  
40021d48:	92 10 21 18 	mov  0x118, %o1                                
40021d4c:	7f ff 82 55 	call  400026a0 <.udiv>                         
40021d50:	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++)                               
40021d54:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40021d58:	02 80 00 1a 	be  40021dc0 <rtems_rfs_rtems_dir_read+0xcc>   <== NEVER TAKEN
40021d5c:	92 07 bf d8 	add  %fp, -40, %o1                             
40021d60:	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,                         
40021d64:	b6 10 20 00 	clr  %i3                                       
40021d68:	10 80 00 0d 	b  40021d9c <rtems_rfs_rtems_dir_read+0xa8>    
40021d6c:	ba 10 20 00 	clr  %i5                                       
    if (rc == ENOENT)                                                 
    {                                                                 
      rc = 0;                                                         
      break;                                                          
    }                                                                 
    if (rc > 0)                                                       
40021d70:	80 a2 20 00 	cmp  %o0, 0                                    
40021d74:	14 80 00 4b 	bg  40021ea0 <rtems_rfs_rtems_dir_read+0x1ac>  <== NEVER TAKEN
40021d78:	d4 07 bf d4 	ld  [ %fp + -44 ], %o2                         
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
      break;                                                          
    }                                                                 
    iop->offset += size;                                              
40021d7c:	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++)                               
40021d80:	b6 06 e0 01 	inc  %i3                                       
    if (rc > 0)                                                       
    {                                                                 
      bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
      break;                                                          
    }                                                                 
    iop->offset += size;                                              
40021d84:	96 80 c0 0a 	addcc  %g3, %o2, %o3                           
40021d88:	94 40 a0 00 	addx  %g2, 0, %o2                              
40021d8c:	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++)                               
40021d90:	80 a6 c0 1a 	cmp  %i3, %i2                                  
40021d94:	02 80 00 0a 	be  40021dbc <rtems_rfs_rtems_dir_read+0xc8>   <== ALWAYS TAKEN
40021d98:	ba 07 61 18 	add  %i5, 0x118, %i5                           
  {                                                                   
    size_t size;                                                      
    rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size); 
40021d9c:	98 06 40 1d 	add  %i1, %i5, %o4                             
40021da0:	90 10 00 10 	mov  %l0, %o0                                  
40021da4:	92 07 bf d8 	add  %fp, -40, %o1                             
40021da8:	7f ff f3 fe 	call  4001eda0 <rtems_rfs_dir_read>            
40021dac:	9a 07 bf d4 	add  %fp, -44, %o5                             
    if (rc == ENOENT)                                                 
40021db0:	80 a2 20 02 	cmp  %o0, 2                                    
40021db4:	12 bf ff ef 	bne  40021d70 <rtems_rfs_rtems_dir_read+0x7c>  
40021db8:	b8 10 00 08 	mov  %o0, %i4                                  
    }                                                                 
    iop->offset += size;                                              
    bytes_transferred += sizeof (struct dirent);                      
  }                                                                   
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
40021dbc:	92 07 bf d8 	add  %fp, -40, %o1                             
40021dc0:	7f ff c6 8a 	call  400137e8 <rtems_rfs_inode_close>         
40021dc4:	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);            
40021dc8:	f8 04 20 80 	ld  [ %l0 + 0x80 ], %i4                        
  rtems_rfs_buffers_release (fs);                                     
40021dcc:	7f ff ef df 	call  4001dd48 <rtems_rfs_buffers_release>     
40021dd0:	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);            
40021dd4:	7f ff b0 94 	call  4000e024 <rtems_semaphore_release>       
40021dd8:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021ddc:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40021de0:	12 80 00 04 	bne  40021df0 <rtems_rfs_rtems_dir_read+0xfc>  <== NEVER TAKEN
40021de4:	90 10 20 00 	clr  %o0                                       
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  return bytes_transferred;                                           
}                                                                     
40021de8:	81 c7 e0 08 	ret                                            
40021dec:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021df0:	7f ff cc ad 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021df4:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021df8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021dfc:	02 bf ff fb 	be  40021de8 <rtems_rfs_rtems_dir_read+0xf4>   <== NOT EXECUTED
40021e00:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40021e04:	7f ff db 03 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021e08:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40021e0c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021e10:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40021e14:	40 00 0c da 	call  4002517c <printf>                        <== NOT EXECUTED
40021e18:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021e1c:	30 bf ff f3 	b,a   40021de8 <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))                      
40021e20:	7f ff cc a1 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021e24:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021e28:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021e2c:	02 bf ff bf 	be  40021d28 <rtems_rfs_rtems_dir_read+0x34>   <== NOT EXECUTED
40021e30:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40021e34:	7f ff da f7 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021e38:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021e3c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021e40:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40021e44:	40 00 0c ce 	call  4002517c <printf>                        <== NOT EXECUTED
40021e48:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_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);                  
40021e4c:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40021e50:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
40021e54:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
40021e58:	7f ff c5 ec 	call  40013608 <rtems_rfs_inode_open>          <== NOT EXECUTED
40021e5c:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc)                                                             
40021e60:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40021e64:	02 bf ff b9 	be  40021d48 <rtems_rfs_rtems_dir_read+0x54>   <== NOT EXECUTED
40021e68:	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);            
40021e6c:	fa 04 20 80 	ld  [ %l0 + 0x80 ], %i5                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40021e70:	7f ff ef b6 	call  4001dd48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40021e74:	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);            
40021e78:	7f ff b0 6b 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
40021e7c:	d0 07 40 00 	ld  [ %i5 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40021e80:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40021e84:	12 80 00 16 	bne  40021edc <rtems_rfs_rtems_dir_read+0x1e8> <== NOT EXECUTED
40021e88:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("dir_read: read inode", rc);        
40021e8c:	40 00 07 2b 	call  40023b38 <__errno>                       <== NOT EXECUTED
40021e90:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
40021e94:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  return bytes_transferred;                                           
}                                                                     
40021e98:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40021e9c:	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);
40021ea0:	40 00 07 26 	call  40023b38 <__errno>                       <== NOT EXECUTED
40021ea4:	ba 10 3f ff 	mov  -1, %i5                                   <== NOT EXECUTED
    }                                                                 
    iop->offset += size;                                              
    bytes_transferred += sizeof (struct dirent);                      
  }                                                                   
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
40021ea8:	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);
40021eac:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
    }                                                                 
    iop->offset += size;                                              
    bytes_transferred += sizeof (struct dirent);                      
  }                                                                   
                                                                      
  rtems_rfs_inode_close (fs, &inode);                                 
40021eb0:	7f ff c6 4e 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40021eb4:	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);            
40021eb8:	f8 04 20 80 	ld  [ %l0 + 0x80 ], %i4                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40021ebc:	7f ff ef a3 	call  4001dd48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40021ec0:	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);            
40021ec4:	7f ff b0 58 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
40021ec8:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40021ecc:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40021ed0:	02 bf ff c6 	be  40021de8 <rtems_rfs_rtems_dir_read+0xf4>   <== NOT EXECUTED
40021ed4:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40021ed8:	30 bf ff c6 	b,a   40021df0 <rtems_rfs_rtems_dir_read+0xfc> <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40021edc:	7f ff cc 72 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021ee0:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40021ee4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021ee8:	02 bf ff e9 	be  40021e8c <rtems_rfs_rtems_dir_read+0x198>  <== NOT EXECUTED
40021eec:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40021ef0:	7f ff da c8 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40021ef4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021ef8:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40021efc:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40021f00:	40 00 0c 9f 	call  4002517c <printf>                        <== NOT EXECUTED
40021f04:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40021f08:	30 bf ff e1 	b,a   40021e8c <rtems_rfs_rtems_dir_read+0x198><== NOT EXECUTED
                                                                      

40014688 <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) {
40014688:	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);
4001468c:	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);                  
40014690:	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);
40014694:	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);                  
40014698:	94 07 bf d8 	add  %fp, -40, %o2                             
4001469c:	90 10 00 1d 	mov  %i5, %o0                                  
400146a0:	7f ff fb da 	call  40013608 <rtems_rfs_inode_open>          
400146a4:	96 10 20 01 	mov  1, %o3                                    
  if (rc == 0) {                                                      
400146a8:	b8 92 20 00 	orcc  %o0, 0, %i4                              
400146ac:	12 80 00 0e 	bne  400146e4 <rtems_rfs_rtems_eval_path+0x5c> <== NEVER TAKEN
400146b0:	92 07 bf d8 	add  %fp, -40, %o1                             
    rtems_filesystem_eval_path_generic (                              
400146b4:	90 10 00 18 	mov  %i0, %o0                                  
400146b8:	15 10 00 dc 	sethi  %hi(0x40037000), %o2                    
400146bc:	40 00 12 d9 	call  40019220 <rtems_filesystem_eval_path_generic>
400146c0:	94 12 a2 00 	or  %o2, 0x200, %o2	! 40037200 <rtems_rfs_rtems_eval_config>
      ctx,                                                            
      &inode,                                                         
      &rtems_rfs_rtems_eval_config                                    
    );                                                                
    rc = rtems_rfs_inode_close (fs, &inode);                          
400146c4:	90 10 00 1d 	mov  %i5, %o0                                  
400146c8:	7f ff fc 48 	call  400137e8 <rtems_rfs_inode_close>         
400146cc:	92 07 bf d8 	add  %fp, -40, %o1                             
    if (rc != 0) {                                                    
400146d0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400146d4:	12 80 00 0c 	bne  40014704 <rtems_rfs_rtems_eval_path+0x7c> <== NEVER TAKEN
400146d8:	01 00 00 00 	nop                                            
400146dc:	81 c7 e0 08 	ret                                            
400146e0:	81 e8 00 00 	restore                                        
      );                                                              
    }                                                                 
  } else {                                                            
    rtems_filesystem_eval_path_error (                                
      ctx,                                                            
      rtems_rfs_rtems_error ("eval_path: opening inode", rc)          
400146e4:	40 00 3d 15 	call  40023b38 <__errno>                       <== NOT EXECUTED
400146e8:	01 00 00 00 	nop                                            <== NOT EXECUTED
        ctx,                                                          
        rtems_rfs_rtems_error ("eval_path: closing inode", rc)        
      );                                                              
    }                                                                 
  } else {                                                            
    rtems_filesystem_eval_path_error (                                
400146ec:	92 10 3f ff 	mov  -1, %o1	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
      ctx,                                                            
      rtems_rfs_rtems_error ("eval_path: opening inode", rc)          
400146f0:	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 (                                
400146f4:	7f ff d8 45 	call  4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
400146f8:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400146fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014700:	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)        
40014704:	40 00 3d 0d 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014708:	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 (                              
4001470c:	92 10 3f ff 	mov  -1, %o1	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
        ctx,                                                          
        rtems_rfs_rtems_error ("eval_path: closing inode", rc)        
40014710:	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 (                              
40014714:	7f ff d8 3d 	call  4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40014718:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4001471c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014720:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40014a30 <rtems_rfs_rtems_eval_token>: rtems_filesystem_eval_path_context_t *ctx, void *arg, const char *token, size_t tokenlen ) {
40014a30:	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);                    
40014a34:	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(                     
40014a38:	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;          
40014a3c:	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;  
40014a40:	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);                    
40014a44:	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;          
40014a48:	d6 08 60 07 	ldub  [ %g1 + 7 ], %o3                         
40014a4c:	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;  
40014a50:	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;          
40014a54:	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);                    
40014a58:	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;  
40014a5c:	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;          
40014a60:	96 10 c0 0b 	or  %g3, %o3, %o3                              
  rtems_filesystem_eval_path_context_t *ctx,                          
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
40014a64:	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;  
40014a68:	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(                     
40014a6c:	97 2a e0 10 	sll  %o3, 0x10, %o3                            
40014a70:	98 13 00 02 	or  %o4, %g2, %o4                              
40014a74:	92 10 20 01 	mov  1, %o1                                    
40014a78:	94 12 80 01 	or  %o2, %g1, %o2                              
40014a7c:	97 32 e0 10 	srl  %o3, 0x10, %o3                            
40014a80:	99 33 20 10 	srl  %o4, 0x10, %o4                            
40014a84:	40 00 11 da 	call  400191ec <rtems_filesystem_eval_path_check_access>
40014a88:	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) {                                                    
40014a8c:	80 8a 20 ff 	btst  0xff, %o0                                
40014a90:	02 80 00 39 	be  40014b74 <rtems_rfs_rtems_eval_token+0x144>
40014a94:	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] == '.';                           
40014a98:	22 80 00 39 	be,a   40014b7c <rtems_rfs_rtems_eval_token+0x14c>
40014a9c:	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);
40014aa0:	c2 07 60 2c 	ld  [ %i5 + 0x2c ], %g1                        
      rtems_rfs_ino entry_ino;                                        
      uint32_t entry_doff;                                            
      int rc = rtems_rfs_dir_lookup_ino (                             
40014aa4:	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);
40014aa8:	f8 00 60 08 	ld  [ %g1 + 8 ], %i4                           
      rtems_rfs_ino entry_ino;                                        
      uint32_t entry_doff;                                            
      int rc = rtems_rfs_dir_lookup_ino (                             
40014aac:	94 10 00 1a 	mov  %i2, %o2                                  
40014ab0:	90 10 00 1c 	mov  %i4, %o0                                  
40014ab4:	96 10 00 1b 	mov  %i3, %o3                                  
40014ab8:	98 07 bf f4 	add  %fp, -12, %o4                             
40014abc:	40 00 25 4b 	call  4001dfe8 <rtems_rfs_dir_lookup_ino>      
40014ac0:	9a 07 bf f8 	add  %fp, -8, %o5                              
        tokenlen,                                                     
        &entry_ino,                                                   
        &entry_doff                                                   
      );                                                              
                                                                      
      if (rc == 0) {                                                  
40014ac4:	80 a2 20 00 	cmp  %o0, 0                                    
40014ac8:	12 80 00 2b 	bne  40014b74 <rtems_rfs_rtems_eval_token+0x144>
40014acc:	b0 10 20 02 	mov  2, %i0                                    
        rc = rtems_rfs_inode_close (fs, inode);                       
40014ad0:	90 10 00 1c 	mov  %i4, %o0                                  
40014ad4:	7f ff fb 45 	call  400137e8 <rtems_rfs_inode_close>         
40014ad8:	92 10 00 19 	mov  %i1, %o1                                  
        if (rc == 0) {                                                
40014adc:	80 a2 20 00 	cmp  %o0, 0                                    
40014ae0:	12 80 00 2d 	bne  40014b94 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
40014ae4:	90 10 00 19 	mov  %i1, %o0                                  
          rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);     
40014ae8:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         
40014aec:	90 10 00 1c 	mov  %i4, %o0                                  
40014af0:	94 10 00 19 	mov  %i1, %o2                                  
40014af4:	7f ff fa c5 	call  40013608 <rtems_rfs_inode_open>          
40014af8:	96 10 20 01 	mov  1, %o3                                    
        }                                                             
                                                                      
        if (rc != 0) {                                                
40014afc:	80 a2 20 00 	cmp  %o0, 0                                    
40014b00:	12 80 00 25 	bne  40014b94 <rtems_rfs_rtems_eval_token+0x164><== NEVER TAKEN
40014b04:	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) 
40014b08:	7f ff fd 0a 	call  40013f30 <rtems_rfs_rtems_node_type_by_inode>
40014b0c:	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);   
40014b10:	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;
40014b14:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
        bool terminal = !rtems_filesystem_eval_path_has_path (ctx);   
40014b18:	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;                                                  
40014b1c:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
40014b20:	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;
40014b24:	85 30 a0 04 	srl  %g2, 4, %g2                               
        bool terminal = !rtems_filesystem_eval_path_has_path (ctx);   
40014b28:	b0 10 00 01 	mov  %g1, %i0                                  
                                                                      
        rtems_filesystem_eval_path_clear_token (ctx);                 
                                                                      
        if (is_sym_link && (follow_sym_link || !terminal)) {          
40014b2c:	80 a2 20 03 	cmp  %o0, 3                                    
40014b30:	12 80 00 07 	bne  40014b4c <rtems_rfs_rtems_eval_token+0x11c>
40014b34:	84 08 a0 01 	and  %g2, 1, %g2                               
40014b38:	80 a0 60 00 	cmp  %g1, 0                                    
40014b3c:	02 80 00 25 	be  40014bd0 <rtems_rfs_rtems_eval_token+0x1a0>
40014b40:	80 88 a0 ff 	btst  0xff, %g2                                
40014b44:	12 80 00 24 	bne  40014bd4 <rtems_rfs_rtems_eval_token+0x1a4>
40014b48:	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;
40014b4c:	90 07 60 18 	add  %i5, 0x18, %o0                            
40014b50:	40 00 01 16 	call  40014fa8 <rtems_rfs_rtems_set_handlers>  
40014b54:	92 10 00 19 	mov  %i1, %o1                                  
40014b58:	80 8a 20 ff 	btst  0xff, %o0                                
40014b5c:	02 80 00 14 	be  40014bac <rtems_rfs_rtems_eval_token+0x17c><== NEVER TAKEN
40014b60:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
40014b64:	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);  
40014b68:	c2 27 60 20 	st  %g1, [ %i5 + 0x20 ]                        
            rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
40014b6c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40014b70:	c2 27 60 24 	st  %g1, [ %i5 + 0x24 ]                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  return status;                                                      
}                                                                     
40014b74:	81 c7 e0 08 	ret                                            
40014b78:	81 e8 00 00 	restore                                        
static inline bool rtems_filesystem_is_current_directory(             
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  return tokenlen == 1 && token [0] == '.';                           
40014b7c:	80 a0 60 2e 	cmp  %g1, 0x2e                                 
40014b80:	32 bf ff c9 	bne,a   40014aa4 <rtems_rfs_rtems_eval_token+0x74>
40014b84:	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;                                                  
40014b88:	c0 27 60 0c 	clr  [ %i5 + 0xc ]                             
40014b8c:	81 c7 e0 08 	ret                                            
40014b90:	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));                          
40014b94:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40014b98:	94 10 20 28 	mov  0x28, %o2                                 <== NOT EXECUTED
40014b9c:	40 00 40 fa 	call  40024f84 <memset>                        <== NOT EXECUTED
40014ba0:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
40014ba4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014ba8:	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)   
40014bac:	40 00 3b e3 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014bb0:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
40014bb4:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
                                                                      
            if (!terminal) {                                          
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;   
            }                                                         
          } else {                                                    
            rtems_filesystem_eval_path_error (                        
40014bb8:	92 10 3f ff 	mov  -1, %o1                                   <== NOT EXECUTED
              ctx,                                                    
              rtems_rfs_rtems_error ("eval_path: set handlers", rc)   
40014bbc:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
                                                                      
            if (!terminal) {                                          
              status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;   
            }                                                         
          } else {                                                    
            rtems_filesystem_eval_path_error (                        
40014bc0:	7f ff d7 12 	call  4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40014bc4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40014bc8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014bcc:	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;                                            
40014bd0:	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);           
40014bd4:	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);                                       
40014bd8:	90 10 24 01 	mov  0x401, %o0                                
40014bdc:	7f ff d2 f0 	call  4000979c <malloc>                        
40014be0:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
                                                                      
  if (link != NULL) {                                                 
40014be4:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40014be8:	02 80 00 14 	be  40014c38 <rtems_rfs_rtems_eval_token+0x208><== NEVER TAKEN
40014bec:	90 10 00 1c 	mov  %i4, %o0                                  
    int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);       
40014bf0:	92 10 00 1a 	mov  %i2, %o1                                  
40014bf4:	94 10 00 1b 	mov  %i3, %o2                                  
40014bf8:	96 10 24 00 	mov  0x400, %o3                                
40014bfc:	40 00 32 82 	call  40021604 <rtems_rfs_symlink_read>        
40014c00:	98 07 bf fc 	add  %fp, -4, %o4                              
                                                                      
    if (rc == 0) {                                                    
40014c04:	80 a2 20 00 	cmp  %o0, 0                                    
40014c08:	12 80 00 09 	bne  40014c2c <rtems_rfs_rtems_eval_token+0x1fc><== NEVER TAKEN
40014c0c:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_filesystem_eval_path_recursive (ctx, link, len);          
40014c10:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
40014c14:	7f ff d8 25 	call  4000aca8 <rtems_filesystem_eval_path_recursive>
40014c18:	92 10 00 1b 	mov  %i3, %o1                                  
    } else {                                                          
      rtems_filesystem_eval_path_error (ctx, 0);                      
    }                                                                 
                                                                      
    free(link);                                                       
40014c1c:	7f ff d1 43 	call  40009128 <free>                          
40014c20:	90 10 00 1b 	mov  %i3, %o0                                  
  void *arg,                                                          
  const char *token,                                                  
  size_t tokenlen                                                     
)                                                                     
{                                                                     
  rtems_filesystem_eval_path_generic_status status =                  
40014c24:	81 c7 e0 08 	ret                                            
40014c28:	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);                      
40014c2c:	7f ff d6 f7 	call  4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40014c30:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40014c34:	30 bf ff fa 	b,a   40014c1c <rtems_rfs_rtems_eval_token+0x1ec><== NOT EXECUTED
    }                                                                 
                                                                      
    free(link);                                                       
  } else {                                                            
    rtems_filesystem_eval_path_error (ctx, ENOMEM);                   
40014c38:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40014c3c:	7f ff d6 f3 	call  4000a808 <rtems_filesystem_eval_path_error><== NOT EXECUTED
40014c40:	92 10 20 0c 	mov  0xc, %o1                                  <== NOT EXECUTED
40014c44:	30 bf ff f8 	b,a   40014c24 <rtems_rfs_rtems_eval_token+0x1f4><== NOT EXECUTED
                                                                      

400143c8 <rtems_rfs_rtems_fchmod>: } static int rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc, mode_t mode) {
400143c8:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
400143cc:	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);                  
400143d0:	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); 
400143d4:	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);                  
400143d8:	94 07 bf d8 	add  %fp, -40, %o2                             
400143dc:	90 10 00 1c 	mov  %i4, %o0                                  
400143e0:	7f ff fc 8a 	call  40013608 <rtems_rfs_inode_open>          
400143e4:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
400143e8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400143ec:	12 80 00 24 	bne  4001447c <rtems_rfs_rtems_fchmod+0xb4>    <== NEVER TAKEN
400143f0:	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);                    
400143f4:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
400143f8:	c2 08 60 03 	ldub  [ %g1 + 3 ], %g1                         
400143fc:	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();                                                    
40014400:	40 00 12 59 	call  40018d64 <geteuid>                       
40014404:	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;          
40014408:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))        
4001440c:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
40014410:	c4 08 60 06 	ldub  [ %g1 + 6 ], %g2                         
40014414:	c6 08 60 07 	ldub  [ %g1 + 7 ], %g3                         
40014418:	85 28 a0 08 	sll  %g2, 8, %g2                               
4001441c:	84 10 80 03 	or  %g2, %g3, %g2                              
40014420:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
40014424:	80 a0 80 08 	cmp  %g2, %o0                                  
40014428:	02 80 00 05 	be  4001443c <rtems_rfs_rtems_fchmod+0x74>     <== ALWAYS TAKEN
4001442c:	89 32 20 10 	srl  %o0, 0x10, %g4                            
40014430:	80 a1 20 00 	cmp  %g4, 0                                    <== NOT EXECUTED
40014434:	12 80 00 17 	bne  40014490 <rtems_rfs_rtems_fchmod+0xc8>    <== NOT EXECUTED
40014438:	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);
4001443c:	ba 0f 70 00 	and  %i5, -4096, %i5                           
  imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
40014440:	b2 0e 6f ff 	and  %i1, 0xfff, %i1                           
40014444:	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);                    
40014448:	85 36 60 08 	srl  %i1, 8, %g2                               
4001444c:	c4 28 60 02 	stb  %g2, [ %g1 + 2 ]                          
40014450:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
                                                                      
  rtems_rfs_inode_set_mode (&inode, imode);                           
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40014454:	90 10 00 1c 	mov  %i4, %o0                                  
40014458:	f2 28 60 03 	stb  %i1, [ %g1 + 3 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
4001445c:	82 10 20 01 	mov  1, %g1                                    
40014460:	92 07 bf d8 	add  %fp, -40, %o1                             
40014464:	c2 2f bf e8 	stb  %g1, [ %fp + -24 ]                        
40014468:	7f ff fc e0 	call  400137e8 <rtems_rfs_inode_close>         
4001446c:	b0 10 20 00 	clr  %i0                                       
  if (rc > 0)                                                         
40014470:	80 a2 20 00 	cmp  %o0, 0                                    
40014474:	04 80 00 05 	ble  40014488 <rtems_rfs_rtems_fchmod+0xc0>    <== ALWAYS TAKEN
40014478:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("fchmod: closing inode", rc);       
4001447c:	40 00 3d af 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014480:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014484:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40014488:	81 c7 e0 08 	ret                                            
4001448c:	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);                               
40014490:	7f ff fc d6 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40014494:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);     
40014498:	40 00 3d a8 	call  40023b38 <__errno>                       <== NOT EXECUTED
4001449c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400144a0:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
400144a4:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
400144a8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400144ac:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40014f74 <rtems_rfs_rtems_fdatasync>: * @param iop * @return int */ int rtems_rfs_rtems_fdatasync (rtems_libio_t* iop) {
40014f74:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  int rc;                                                             
                                                                      
  rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
40014f78:	c2 06 20 28 	ld  [ %i0 + 0x28 ], %g1                        <== NOT EXECUTED
  if (rc)                                                             
    return rtems_rfs_rtems_error ("fdatasync: sync", rc);             
                                                                      
  return 0;                                                           
40014f7c:	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));
40014f80:	40 00 23 4c 	call  4001dcb0 <rtems_rfs_buffer_sync>         <== NOT EXECUTED
40014f84:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           <== NOT EXECUTED
  if (rc)                                                             
40014f88:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40014f8c:	02 80 00 05 	be  40014fa0 <rtems_rfs_rtems_fdatasync+0x2c>  <== NOT EXECUTED
40014f90:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("fdatasync: sync", rc);             
40014f94:	40 00 3a e9 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014f98:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014f9c:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
                                                                      
  return 0;                                                           
}                                                                     
40014fa0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014fa4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400220f8 <rtems_rfs_rtems_file_close>: * @param iop * @return int */ static int rtems_rfs_rtems_file_close (rtems_libio_t* iop) {
400220f8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400220fc:	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);
40022100:	92 10 20 00 	clr  %o1                                       
  rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);               
40022104:	c2 07 20 1c 	ld  [ %i4 + 0x1c ], %g1                        
40022108:	94 10 20 00 	clr  %o2                                       
4002210c:	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                       
};                                                                    
40022110:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
40022114:	7f ff af 75 	call  4000dee8 <rtems_semaphore_obtain>        
40022118:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
4002211c:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40022120:	12 80 00 21 	bne  400221a4 <rtems_rfs_rtems_file_close+0xac><== NEVER TAKEN
40022124:	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);                               
40022128:	90 10 00 1d 	mov  %i5, %o0                                  
4002212c:	7f ff f5 7e 	call  4001f724 <rtems_rfs_file_close>          
40022130:	92 10 00 1c 	mov  %i4, %o1                                  
  if (rc > 0)                                                         
40022134:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40022138:	24 80 00 07 	ble,a   40022154 <rtems_rfs_rtems_file_close+0x5c><== ALWAYS TAKEN
4002213c:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        
    rc = rtems_rfs_rtems_error ("file-close: file close", rc);        
40022140:	40 00 06 7e 	call  40023b38 <__errno>                       <== NOT EXECUTED
40022144:	01 00 00 00 	nop                                            <== NOT EXECUTED
40022148:	f0 22 00 00 	st  %i0, [ %o0 ]                               <== NOT EXECUTED
4002214c:	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);            
40022150:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
40022154:	7f ff ee fd 	call  4001dd48 <rtems_rfs_buffers_release>     
40022158:	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);            
4002215c:	7f ff af b2 	call  4000e024 <rtems_semaphore_release>       
40022160:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40022164:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40022168:	02 80 00 0d 	be  4002219c <rtems_rfs_rtems_file_close+0xa4> <== ALWAYS TAKEN
4002216c:	90 10 20 00 	clr  %o0                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40022170:	7f ff cb cd 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40022174:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40022178:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4002217c:	02 80 00 08 	be  4002219c <rtems_rfs_rtems_file_close+0xa4> <== NOT EXECUTED
40022180:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40022184:	7f ff da 23 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40022188:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4002218c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40022190:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40022194:	40 00 0b fa 	call  4002517c <printf>                        <== NOT EXECUTED
40022198:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
  return rc;                                                          
}                                                                     
4002219c:	81 c7 e0 08 	ret                                            
400221a0:	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))                      
400221a4:	7f ff cb c0 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400221a8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400221ac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400221b0:	22 bf ff df 	be,a   4002212c <rtems_rfs_rtems_file_close+0x34><== NOT EXECUTED
400221b4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
400221b8:	7f ff da 16 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
400221bc:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
400221c0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400221c4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
400221c8:	40 00 0b ed 	call  4002517c <printf>                        <== NOT EXECUTED
400221cc:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_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);                               
400221d0:	10 bf ff d7 	b  4002212c <rtems_rfs_rtems_file_close+0x34>  <== NOT EXECUTED
400221d4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
                                                                      

400221d8 <rtems_rfs_rtems_file_ftruncate>: * @return int */ static int rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop, off_t length) {
400221d8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400221dc:	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);
400221e0:	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));                    
400221e4:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        
400221e8:	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);            
400221ec:	c2 00 60 98 	ld  [ %g1 + 0x98 ], %g1                        
 * @return int                                                        
 */                                                                   
static int                                                            
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,                   
                                off_t          length)                
{                                                                     
400221f0:	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                       
};                                                                    
400221f4:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1                        
 * @return int                                                        
 */                                                                   
static int                                                            
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,                   
                                off_t          length)                
{                                                                     
400221f8:	b8 10 00 19 	mov  %i1, %i4                                  
400221fc:	7f ff af 3b 	call  4000dee8 <rtems_semaphore_obtain>        
40022200:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40022204:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40022208:	12 80 00 23 	bne  40022294 <rtems_rfs_rtems_file_ftruncate+0xbc><== NEVER TAKEN
4002220c:	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);                        
40022210:	90 10 00 1b 	mov  %i3, %o0                                  
40022214:	92 10 00 1c 	mov  %i4, %o1                                  
40022218:	7f ff f7 93 	call  40020064 <rtems_rfs_file_set_size>       
4002221c:	94 10 00 1d 	mov  %i5, %o2                                  
  if (rc)                                                             
40022220:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40022224:	22 80 00 07 	be,a   40022240 <rtems_rfs_rtems_file_ftruncate+0x68><== ALWAYS TAKEN
40022228:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        
    rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);      
4002222c:	40 00 06 43 	call  40023b38 <__errno>                       <== NOT EXECUTED
40022230:	01 00 00 00 	nop                                            <== NOT EXECUTED
40022234:	f0 22 00 00 	st  %i0, [ %o0 ]                               <== NOT EXECUTED
40022238:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
4002223c:	c2 06 e0 1c 	ld  [ %i3 + 0x1c ], %g1                        <== NOT EXECUTED
40022240:	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);                                     
40022244:	7f ff ee c1 	call  4001dd48 <rtems_rfs_buffers_release>     
40022248:	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);            
4002224c:	7f ff af 76 	call  4000e024 <rtems_semaphore_release>       
40022250:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40022254:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40022258:	02 80 00 0d 	be  4002228c <rtems_rfs_rtems_file_ftruncate+0xb4><== ALWAYS TAKEN
4002225c:	90 10 20 00 	clr  %o0                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40022260:	7f ff cb 91 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40022264:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40022268:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4002226c:	02 80 00 08 	be  4002228c <rtems_rfs_rtems_file_ftruncate+0xb4><== NOT EXECUTED
40022270:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40022274:	7f ff d9 e7 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40022278:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4002227c:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40022280:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40022284:	40 00 0b be 	call  4002517c <printf>                        <== NOT EXECUTED
40022288:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
                                                                      
  return rc;                                                          
}                                                                     
4002228c:	81 c7 e0 08 	ret                                            
40022290:	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))                      
40022294:	7f ff cb 84 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40022298:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
4002229c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400222a0:	22 bf ff dd 	be,a   40022214 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
400222a4:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
400222a8:	7f ff d9 da 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
400222ac:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
400222b0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400222b4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
400222b8:	40 00 0b b1 	call  4002517c <printf>                        <== NOT EXECUTED
400222bc:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_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);                        
400222c0:	10 bf ff d5 	b  40022214 <rtems_rfs_rtems_file_ftruncate+0x3c><== NOT EXECUTED
400222c4:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
                                                                      

400222c8 <rtems_rfs_rtems_file_lseek>: */ static off_t rtems_rfs_rtems_file_lseek (rtems_libio_t* iop, off_t offset, int whence) {
400222c8:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400222cc:	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);
400222d0:	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));                    
400222d4:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
400222d8:	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);            
400222dc:	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)                    
{                                                                     
400222e0:	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                       
};                                                                    
400222e4:	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)                    
{                                                                     
400222e8:	ba 10 00 1a 	mov  %i2, %i5                                  
400222ec:	d0 00 40 00 	ld  [ %g1 ], %o0                               
400222f0:	7f ff ae fe 	call  4000dee8 <rtems_semaphore_obtain>        
400222f4:	b2 10 00 1b 	mov  %i3, %i1                                  
  if (sc != RTEMS_SUCCESSFUL)                                         
400222f8:	b4 92 20 00 	orcc  %o0, 0, %i2                              
400222fc:	12 80 00 22 	bne  40022384 <rtems_rfs_rtems_file_lseek+0xbc><== NEVER TAKEN
40022300:	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);
40022304:	92 10 00 1c 	mov  %i4, %o1                                  
40022308:	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;                                           
4002230c:	f4 1e 20 08 	ldd  [ %i0 + 8 ], %i2                          
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
40022310:	90 10 00 18 	mov  %i0, %o0                                  
40022314:	40 00 01 99 	call  40022978 <rtems_filesystem_default_lseek_file>
40022318:	96 10 00 19 	mov  %i1, %o3                                  
4002231c:	b8 10 00 08 	mov  %o0, %i4                                  
  if (new_offset != -1)                                               
40022320:	80 a7 3f ff 	cmp  %i4, -1                                   
40022324:	02 80 00 2d 	be  400223d8 <rtems_rfs_rtems_file_lseek+0x110>
40022328:	ba 10 00 09 	mov  %o1, %i5                                  
  {                                                                   
    rtems_rfs_pos pos = iop->offset;                                  
4002232c:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
40022330:	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;                                  
40022334:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
40022338:	92 10 00 02 	mov  %g2, %o1                                  
4002233c:	94 10 00 03 	mov  %g3, %o2                                  
40022340:	7f ff f7 06 	call  4001ff58 <rtems_rfs_file_seek>           
40022344:	96 07 bf f8 	add  %fp, -8, %o3                              
                                                                      
    if (rc)                                                           
40022348:	b2 92 20 00 	orcc  %o0, 0, %i1                              
4002234c:	12 80 00 30 	bne  4002240c <rtems_rfs_rtems_file_lseek+0x144><== NEVER TAKEN
40022350:	01 00 00 00 	nop                                            
      iop->offset = old_offset;                                       
      new_offset = -1;                                                
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
40022354:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
40022358:	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);                                     
4002235c:	7f ff ee 7b 	call  4001dd48 <rtems_rfs_buffers_release>     
40022360:	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);            
40022364:	7f ff af 30 	call  4000e024 <rtems_semaphore_release>       
40022368:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
4002236c:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40022370:	12 80 00 36 	bne  40022448 <rtems_rfs_rtems_file_lseek+0x180><== NEVER TAKEN
40022374:	90 10 20 00 	clr  %o0                                       
                                                                      
  return new_offset;                                                  
}                                                                     
40022378:	b0 10 00 1c 	mov  %i4, %i0                                  
4002237c:	81 c7 e0 08 	ret                                            
40022380:	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))                      
40022384:	7f ff cb 48 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40022388:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
4002238c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40022390:	02 bf ff de 	be  40022308 <rtems_rfs_rtems_file_lseek+0x40> <== NOT EXECUTED
40022394:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40022398:	7f ff d9 9e 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
4002239c:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
400223a0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400223a4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
400223a8:	40 00 0b 75 	call  4002517c <printf>                        <== NOT EXECUTED
400223ac:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_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);
400223b0:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
400223b4:	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;                                           
400223b8:	f4 1e 20 08 	ldd  [ %i0 + 8 ], %i2                          <== NOT EXECUTED
  new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
400223bc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400223c0:	40 00 01 6e 	call  40022978 <rtems_filesystem_default_lseek_file><== NOT EXECUTED
400223c4:	96 10 00 19 	mov  %i1, %o3                                  <== NOT EXECUTED
400223c8:	b8 10 00 08 	mov  %o0, %i4                                  <== NOT EXECUTED
  if (new_offset != -1)                                               
400223cc:	80 a7 3f ff 	cmp  %i4, -1                                   <== NOT EXECUTED
400223d0:	12 bf ff d7 	bne  4002232c <rtems_rfs_rtems_file_lseek+0x64><== NOT EXECUTED
400223d4:	ba 10 00 09 	mov  %o1, %i5                                  <== NOT EXECUTED
400223d8:	80 a2 7f ff 	cmp  %o1, -1                                   
400223dc:	22 bf ff df 	be,a   40022358 <rtems_rfs_rtems_file_lseek+0x90><== ALWAYS TAKEN
400223e0:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
  {                                                                   
    rtems_rfs_pos pos = iop->offset;                                  
400223e4:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          <== NOT EXECUTED
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
400223e8:	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;                                  
400223ec:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         <== NOT EXECUTED
    int           rc = rtems_rfs_file_seek (file, pos, &pos);         
400223f0:	92 10 00 02 	mov  %g2, %o1                                  <== NOT EXECUTED
400223f4:	94 10 00 03 	mov  %g3, %o2                                  <== NOT EXECUTED
400223f8:	7f ff f6 d8 	call  4001ff58 <rtems_rfs_file_seek>           <== NOT EXECUTED
400223fc:	96 07 bf f8 	add  %fp, -8, %o3                              <== NOT EXECUTED
                                                                      
    if (rc)                                                           
40022400:	b2 92 20 00 	orcc  %o0, 0, %i1                              <== NOT EXECUTED
40022404:	22 bf ff d5 	be,a   40022358 <rtems_rfs_rtems_file_lseek+0x90><== NOT EXECUTED
40022408:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
    {                                                                 
      rtems_rfs_rtems_error ("file_lseek: lseek", rc);                
4002240c:	40 00 05 cb 	call  40023b38 <__errno>                       <== NOT EXECUTED
40022410:	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));                  
40022414:	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);                
40022418:	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));                  
4002241c:	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;                                       
40022420:	f4 3e 20 08 	std  %i2, [ %i0 + 8 ]                          <== NOT EXECUTED
40022424:	7f ff ee 49 	call  4001dd48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40022428:	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);            
4002242c:	7f ff ae fe 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
40022430:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
      new_offset = -1;                                                
40022434:	b8 17 23 ff 	or  %i4, 0x3ff, %i4                            <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40022438:	b6 92 20 00 	orcc  %o0, 0, %i3                              <== NOT EXECUTED
4002243c:	02 bf ff cf 	be  40022378 <rtems_rfs_rtems_file_lseek+0xb0> <== NOT EXECUTED
40022440:	ba 10 00 1c 	mov  %i4, %i5                                  <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40022444:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40022448:	7f ff cb 17 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4002244c:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40022450:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40022454:	22 bf ff ca 	be,a   4002237c <rtems_rfs_rtems_file_lseek+0xb4><== NOT EXECUTED
40022458:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
4002245c:	7f ff d9 6d 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40022460:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
  }                                                                   
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
                                                                      
  return new_offset;                                                  
}                                                                     
40022464:	b0 10 00 1c 	mov  %i4, %i0                                  <== NOT EXECUTED
40022468:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4002246c:	b2 10 00 1d 	mov  %i5, %i1                                  <== NOT EXECUTED
40022470:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40022474:	40 00 0b 42 	call  4002517c <printf>                        <== NOT EXECUTED
40022478:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
4002247c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40022480:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40022484 <rtems_rfs_rtems_file_open>: static int rtems_rfs_rtems_file_open (rtems_libio_t* iop, const char* pathname, int oflag, mode_t mode) {
40022484:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
40022488:	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);
4002248c:	92 10 20 00 	clr  %o1                                       
40022490:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           
40022494:	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                       
};                                                                    
40022498:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
4002249c:	7f ff ae 93 	call  4000dee8 <rtems_semaphore_obtain>        
400224a0:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
400224a4:	b8 92 20 00 	orcc  %o0, 0, %i4                              
400224a8:	12 80 00 23 	bne  40022534 <rtems_rfs_rtems_file_open+0xb0> <== NEVER TAKEN
400224ac:	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);                   
400224b0:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        
400224b4:	90 10 00 1d 	mov  %i5, %o0                                  
400224b8:	94 10 20 00 	clr  %o2                                       
400224bc:	7f ff f3 c9 	call  4001f3e0 <rtems_rfs_file_open>           
400224c0:	96 07 bf fc 	add  %fp, -4, %o3                              
  if (rc > 0)                                                         
400224c4:	b8 92 20 00 	orcc  %o0, 0, %i4                              
400224c8:	04 80 00 2f 	ble  40022584 <rtems_rfs_rtems_file_open+0x100><== ALWAYS TAKEN
400224cc:	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);            
400224d0:	f6 07 60 80 	ld  [ %i5 + 0x80 ], %i3                        <== NOT EXECUTED
  rtems_rfs_buffers_release (fs);                                     
400224d4:	7f ff ee 1d 	call  4001dd48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
400224d8:	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);            
400224dc:	7f ff ae d2 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
400224e0:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
400224e4:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
400224e8:	12 80 00 07 	bne  40022504 <rtems_rfs_rtems_file_open+0x80> <== NOT EXECUTED
400224ec:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
  {                                                                   
    rtems_rfs_rtems_unlock (fs);                                      
    return rtems_rfs_rtems_error ("file-open: open", rc);             
400224f0:	40 00 05 92 	call  40023b38 <__errno>                       <== NOT EXECUTED
400224f4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400224f8:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
400224fc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40022500:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40022504:	7f ff ca e8 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40022508:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
4002250c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40022510:	02 bf ff f8 	be  400224f0 <rtems_rfs_rtems_file_open+0x6c>  <== NOT EXECUTED
40022514:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40022518:	7f ff d9 3e 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
4002251c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40022520:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40022524:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40022528:	40 00 0b 15 	call  4002517c <printf>                        <== NOT EXECUTED
4002252c:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40022530:	30 bf ff f0 	b,a   400224f0 <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))                      
40022534:	7f ff ca dc 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40022538:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
4002253c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40022540:	22 bf ff dd 	be,a   400224b4 <rtems_rfs_rtems_file_open+0x30><== NOT EXECUTED
40022544:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40022548:	7f ff d9 32 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
4002254c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40022550:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40022554:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40022558:	40 00 0b 09 	call  4002517c <printf>                        <== NOT EXECUTED
4002255c:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_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);                   
40022560:	d2 06 20 1c 	ld  [ %i0 + 0x1c ], %o1                        <== NOT EXECUTED
40022564:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40022568:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
4002256c:	7f ff f3 9d 	call  4001f3e0 <rtems_rfs_file_open>           <== NOT EXECUTED
40022570:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
  if (rc > 0)                                                         
40022574:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40022578:	34 bf ff d7 	bg,a   400224d4 <rtems_rfs_rtems_file_open+0x50><== NOT EXECUTED
4002257c:	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);                    
40022580:	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);            
40022584:	f8 07 60 80 	ld  [ %i5 + 0x80 ], %i4                        
  rtems_rfs_buffers_release (fs);                                     
40022588:	90 10 00 1d 	mov  %i5, %o0                                  
4002258c:	7f ff ed ef 	call  4001dd48 <rtems_rfs_buffers_release>     
40022590:	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);            
40022594:	7f ff ae a4 	call  4000e024 <rtems_semaphore_release>       
40022598:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
4002259c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400225a0:	12 80 00 04 	bne  400225b0 <rtems_rfs_rtems_file_open+0x12c><== NEVER TAKEN
400225a4:	90 10 20 00 	clr  %o0                                       
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
  return 0;                                                           
}                                                                     
400225a8:	81 c7 e0 08 	ret                                            
400225ac:	91 e8 20 00 	restore  %g0, 0, %o0                           
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400225b0:	7f ff ca bd 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400225b4:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400225b8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400225bc:	02 bf ff fb 	be  400225a8 <rtems_rfs_rtems_file_open+0x124> <== NOT EXECUTED
400225c0:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
400225c4:	7f ff d9 13 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
400225c8:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400225cc:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400225d0:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
400225d4:	40 00 0a ea 	call  4002517c <printf>                        <== NOT EXECUTED
400225d8:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400225dc:	30 bf ff f3 	b,a   400225a8 <rtems_rfs_rtems_file_open+0x124><== NOT EXECUTED
                                                                      

40021f0c <rtems_rfs_rtems_file_read>: */ static ssize_t rtems_rfs_rtems_file_read (rtems_libio_t* iop, void* buffer, size_t count) {
40021f0c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
40021f10:	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);
40021f14:	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));                    
40021f18:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
40021f1c:	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);            
40021f20:	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)                      
{                                                                     
40021f24:	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                       
};                                                                    
40021f28:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1                        
40021f2c:	7f ff af ef 	call  4000dee8 <rtems_semaphore_obtain>        
40021f30:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021f34:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021f38:	12 80 00 5b 	bne  400220a4 <rtems_rfs_rtems_file_read+0x198><== NEVER TAKEN
40021f3c:	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))                               
40021f40:	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;                                                  
40021f44:	f8 1c 60 08 	ldd  [ %l1 + 8 ], %i4                          
40021f48:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
40021f4c:	7f ff ea 1b 	call  4001c7b8 <rtems_rfs_block_get_size>      
40021f50:	92 02 60 84 	add  %o1, 0x84, %o1                            
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
40021f54:	80 a2 00 1c 	cmp  %o0, %i4                                  
40021f58:	18 80 00 19 	bgu  40021fbc <rtems_rfs_rtems_file_read+0xb0> <== NEVER TAKEN
40021f5c:	80 a6 a0 00 	cmp  %i2, 0                                    
40021f60:	80 a2 00 1c 	cmp  %o0, %i4                                  
40021f64:	02 80 00 13 	be  40021fb0 <rtems_rfs_rtems_file_read+0xa4>  <== ALWAYS TAKEN
40021f68:	80 a2 40 1d 	cmp  %o1, %i5                                  
  {                                                                   
    while (count)                                                     
40021f6c:	84 10 20 00 	clr  %g2                                       <== NOT EXECUTED
40021f70:	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;                                    
40021f74:	b0 10 20 00 	clr  %i0                                       
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (read >= 0)                                                      
    iop->offset = pos + read;                                         
40021f78:	b6 80 c0 1d 	addcc  %g3, %i5, %i3                           
40021f7c:	b4 40 80 1c 	addx  %g2, %i4, %i2                            
40021f80:	f4 3c 60 08 	std  %i2, [ %l1 + 8 ]                          
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
40021f84:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
40021f88:	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);                                     
40021f8c:	7f ff ef 6f 	call  4001dd48 <rtems_rfs_buffers_release>     
40021f90:	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);            
40021f94:	7f ff b0 24 	call  4000e024 <rtems_semaphore_release>       
40021f98:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40021f9c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021fa0:	12 80 00 2f 	bne  4002205c <rtems_rfs_rtems_file_read+0x150><== NEVER TAKEN
40021fa4:	90 10 20 00 	clr  %o0                                       
                                                                      
  return read;                                                        
}                                                                     
40021fa8:	81 c7 e0 08 	ret                                            
40021fac:	81 e8 00 00 	restore                                        
                                                                      
  rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));                    
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
40021fb0:	08 bf ff f0 	bleu  40021f70 <rtems_rfs_rtems_file_read+0x64>
40021fb4:	84 10 20 00 	clr  %g2                                       
  {                                                                   
    while (count)                                                     
40021fb8:	80 a6 a0 00 	cmp  %i2, 0                                    
40021fbc:	02 bf ff ec 	be  40021f6c <rtems_rfs_rtems_file_read+0x60>  <== NEVER TAKEN
40021fc0:	b0 10 20 00 	clr  %i0                                       
    {                                                                 
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
40021fc4:	10 80 00 16 	b  4002201c <rtems_rfs_rtems_file_read+0x110>  
40021fc8:	92 07 bf fc 	add  %fp, -4, %o1                              
        break;                                                        
                                                                      
      if (size > count)                                               
        size = count;                                                 
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
40021fcc:	c4 04 20 0c 	ld  [ %l0 + 0xc ], %g2                         
40021fd0:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
40021fd4:	d2 00 a0 1c 	ld  [ %g2 + 0x1c ], %o1                        
40021fd8:	90 10 00 19 	mov  %i1, %o0                                  
40021fdc:	92 02 40 01 	add  %o1, %g1, %o1                             
40021fe0:	40 00 0b 5a 	call  40024d48 <memcpy>                        
40021fe4:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
      data  += size;                                                  
      count -= size;                                                  
      read  += size;                                                  
                                                                      
      rc = rtems_rfs_file_io_end (file, size, true);                  
40021fe8:	90 10 00 10 	mov  %l0, %o0                                  
40021fec:	92 10 00 1b 	mov  %i3, %o1                                  
40021ff0:	94 10 20 01 	mov  1, %o2                                    
40021ff4:	7f ff f7 1f 	call  4001fc70 <rtems_rfs_file_io_end>         
40021ff8:	b2 06 40 1b 	add  %i1, %i3, %i1                             
                                                                      
      memcpy (data, rtems_rfs_file_data (file), size);                
                                                                      
      data  += size;                                                  
      count -= size;                                                  
      read  += size;                                                  
40021ffc:	b0 06 c0 18 	add  %i3, %i0, %i0                             
                                                                      
      rc = rtems_rfs_file_io_end (file, size, true);                  
      if (rc > 0)                                                     
40022000:	80 a2 20 00 	cmp  %o0, 0                                    
40022004:	14 80 00 39 	bg  400220e8 <rtems_rfs_rtems_file_read+0x1dc> <== NEVER TAKEN
40022008:	a4 10 00 08 	mov  %o0, %l2                                  
                                                                      
  pos = iop->offset;                                                  
                                                                      
  if (pos < rtems_rfs_file_size (file))                               
  {                                                                   
    while (count)                                                     
4002200c:	80 a6 a0 00 	cmp  %i2, 0                                    
40022010:	02 80 00 21 	be  40022094 <rtems_rfs_rtems_file_read+0x188> 
40022014:	80 a6 20 00 	cmp  %i0, 0                                    
    {                                                                 
      size_t size;                                                    
                                                                      
      rc = rtems_rfs_file_io_start (file, &size, true);               
40022018:	92 07 bf fc 	add  %fp, -4, %o1                              
4002201c:	94 10 20 01 	mov  1, %o2                                    
40022020:	7f ff f6 83 	call  4001fa2c <rtems_rfs_file_io_start>       
40022024:	90 10 00 10 	mov  %l0, %o0                                  
      if (rc > 0)                                                     
40022028:	b6 92 20 00 	orcc  %o0, 0, %i3                              
4002202c:	14 80 00 2b 	bg  400220d8 <rtems_rfs_rtems_file_read+0x1cc> <== NEVER TAKEN
40022030:	01 00 00 00 	nop                                            
      {                                                               
        read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
        break;                                                        
      }                                                               
                                                                      
      if (size == 0)                                                  
40022034:	f6 07 bf fc 	ld  [ %fp + -4 ], %i3                          
40022038:	80 a6 e0 00 	cmp  %i3, 0                                    
4002203c:	02 80 00 15 	be  40022090 <rtems_rfs_rtems_file_read+0x184> 
40022040:	80 a6 c0 1a 	cmp  %i3, %i2                                  
        break;                                                        
                                                                      
      if (size > count)                                               
40022044:	28 bf ff e2 	bleu,a   40021fcc <rtems_rfs_rtems_file_read+0xc0>
40022048:	b4 26 80 1b 	sub  %i2, %i3, %i2                             
        size = count;                                                 
4002204c:	b6 10 00 1a 	mov  %i2, %i3                                  
40022050:	f4 27 bf fc 	st  %i2, [ %fp + -4 ]                          
40022054:	10 bf ff de 	b  40021fcc <rtems_rfs_rtems_file_read+0xc0>   
40022058:	b4 10 20 00 	clr  %i2                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
4002205c:	7f ff cc 12 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40022060:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40022064:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40022068:	02 80 00 08 	be  40022088 <rtems_rfs_rtems_file_read+0x17c> <== NOT EXECUTED
4002206c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40022070:	7f ff da 68 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40022074:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40022078:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
4002207c:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40022080:	40 00 0c 3f 	call  4002517c <printf>                        <== NOT EXECUTED
40022084:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
    iop->offset = pos + read;                                         
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
                                                                      
  return read;                                                        
}                                                                     
40022088:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4002208c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        break;                                                        
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (read >= 0)                                                      
40022090:	80 a6 20 00 	cmp  %i0, 0                                    
40022094:	06 bf ff bc 	bl  40021f84 <rtems_rfs_rtems_file_read+0x78>  <== NEVER TAKEN
40022098:	86 10 00 18 	mov  %i0, %g3                                  
4002209c:	10 bf ff b7 	b  40021f78 <rtems_rfs_rtems_file_read+0x6c>   
400220a0:	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))                      
400220a4:	7f ff cc 00 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400220a8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400220ac:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400220b0:	22 bf ff a5 	be,a   40021f44 <rtems_rfs_rtems_file_read+0x38><== NOT EXECUTED
400220b4:	d2 04 20 1c 	ld  [ %l0 + 0x1c ], %o1                        <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
400220b8:	7f ff da 56 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
400220bc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400220c0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400220c4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
400220c8:	40 00 0c 2d 	call  4002517c <printf>                        <== NOT EXECUTED
400220cc:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_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))                               
400220d0:	10 bf ff 9d 	b  40021f44 <rtems_rfs_rtems_file_read+0x38>   <== NOT EXECUTED
400220d4:	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);
400220d8:	40 00 06 98 	call  40023b38 <__errno>                       <== NOT EXECUTED
400220dc:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400220e0:	10 bf ff a9 	b  40021f84 <rtems_rfs_rtems_file_read+0x78>   <== NOT EXECUTED
400220e4:	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); 
400220e8:	40 00 06 94 	call  40023b38 <__errno>                       <== NOT EXECUTED
400220ec:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400220f0:	10 bf ff a5 	b  40021f84 <rtems_rfs_rtems_file_read+0x78>   <== NOT EXECUTED
400220f4:	e4 22 00 00 	st  %l2, [ %o0 ]                               <== NOT EXECUTED
                                                                      

400225e0 <rtems_rfs_rtems_file_write>: */ static ssize_t rtems_rfs_rtems_file_write (rtems_libio_t* iop, const void* buffer, size_t count) {
400225e0:	9d e3 bf 90 	save  %sp, -112, %sp                           
  rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
400225e4:	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);
400225e8:	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));                    
400225ec:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
400225f0:	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);            
400225f4:	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                       
};                                                                    
400225f8:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1                        
400225fc:	7f ff ae 3b 	call  4000dee8 <rtems_semaphore_obtain>        
40022600:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40022604:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40022608:	12 80 00 70 	bne  400227c8 <rtems_rfs_rtems_file_write+0x1e8><== NEVER TAKEN
4002260c:	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);                             
40022610:	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;                                                  
40022614:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          
40022618:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        
4002261c:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         
40022620:	7f ff e8 66 	call  4001c7b8 <rtems_rfs_block_get_size>      
40022624:	92 02 60 84 	add  %o1, 0x84, %o1                            
40022628:	86 10 00 09 	mov  %o1, %g3                                  
  file_size = rtems_rfs_file_size (file);                             
  if (pos > file_size)                                                
4002262c:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
40022630:	84 10 00 08 	mov  %o0, %g2                                  
40022634:	80 a2 40 02 	cmp  %o1, %g2                                  
40022638:	18 80 00 7b 	bgu  40022824 <rtems_rfs_rtems_file_write+0x244><== NEVER TAKEN
4002263c:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
40022640:	80 a2 40 02 	cmp  %o1, %g2                                  
40022644:	02 80 00 8b 	be  40022870 <rtems_rfs_rtems_file_write+0x290><== ALWAYS TAKEN
40022648:	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) 
4002264c:	80 a0 80 09 	cmp  %g2, %o1                                  <== NOT EXECUTED
40022650:	08 80 00 3b 	bleu  4002273c <rtems_rfs_rtems_file_write+0x15c><== ALWAYS TAKEN
40022654:	01 00 00 00 	nop                                            
40022658:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        <== NOT EXECUTED
4002265c:	80 88 62 00 	btst  0x200, %g1                               
40022660:	32 80 00 8d 	bne,a   40022894 <rtems_rfs_rtems_file_write+0x2b4>
40022664:	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)                                                       
40022668:	a2 10 20 00 	clr  %l1                                       
4002266c:	84 10 20 00 	clr  %g2                                       
40022670:	80 a6 a0 00 	cmp  %i2, 0                                    
40022674:	12 80 00 1b 	bne  400226e0 <rtems_rfs_rtems_file_write+0x100><== ALWAYS TAKEN
40022678:	86 10 20 00 	clr  %g3                                       
  }                                                                   
                                                                      
  if (write >= 0)                                                     
    iop->offset = pos + write;                                        
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
4002267c:	10 80 00 3b 	b  40022768 <rtems_rfs_rtems_file_write+0x188> <== NOT EXECUTED
40022680:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
    {                                                                 
      write = rtems_rfs_rtems_error ("file-write: write open", rc);   
      break;                                                          
    }                                                                 
                                                                      
    if (size > count)                                                 
40022684:	d4 07 bf f4 	ld  [ %fp + -12 ], %o2                         
40022688:	80 a2 80 1a 	cmp  %o2, %i2                                  
4002268c:	28 80 00 05 	bleu,a   400226a0 <rtems_rfs_rtems_file_write+0xc0>
40022690:	c4 04 20 0c 	ld  [ %l0 + 0xc ], %g2                         
      size = count;                                                   
40022694:	f4 27 bf f4 	st  %i2, [ %fp + -12 ]                         
40022698:	94 10 00 1a 	mov  %i2, %o2                                  
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
4002269c:	c4 04 20 0c 	ld  [ %l0 + 0xc ], %g2                         
400226a0:	c2 04 20 14 	ld  [ %l0 + 0x14 ], %g1                        
400226a4:	d0 00 a0 1c 	ld  [ %g2 + 0x1c ], %o0                        
400226a8:	40 00 09 a8 	call  40024d48 <memcpy>                        
400226ac:	90 02 00 01 	add  %o0, %g1, %o0                             
                                                                      
    data  += size;                                                    
400226b0:	d2 07 bf f4 	ld  [ %fp + -12 ], %o1                         
    count -= size;                                                    
    write  += size;                                                   
                                                                      
    rc = rtems_rfs_file_io_end (file, size, false);                   
400226b4:	90 10 00 10 	mov  %l0, %o0                                  
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
                                                                      
    data  += size;                                                    
    count -= size;                                                    
400226b8:	b4 26 80 09 	sub  %i2, %o1, %i2                             
    if (size > count)                                                 
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
                                                                      
    data  += size;                                                    
400226bc:	b2 06 40 09 	add  %i1, %o1, %i1                             
    count -= size;                                                    
    write  += size;                                                   
400226c0:	a2 04 40 09 	add  %l1, %o1, %l1                             
                                                                      
    rc = rtems_rfs_file_io_end (file, size, false);                   
400226c4:	7f ff f5 6b 	call  4001fc70 <rtems_rfs_file_io_end>         
400226c8:	94 10 20 00 	clr  %o2                                       
    if (rc)                                                           
400226cc:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400226d0:	12 80 00 0d 	bne  40022704 <rtems_rfs_rtems_file_write+0x124><== NEVER TAKEN
400226d4:	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)                                                       
400226d8:	02 80 00 20 	be  40022758 <rtems_rfs_rtems_file_write+0x178>
400226dc:	86 10 00 11 	mov  %l1, %g3                                  
  {                                                                   
    size_t size = count;                                              
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
400226e0:	92 07 bf f4 	add  %fp, -12, %o1                             
    }                                                                 
  }                                                                   
                                                                      
  while (count)                                                       
  {                                                                   
    size_t size = count;                                              
400226e4:	f4 27 bf f4 	st  %i2, [ %fp + -12 ]                         
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
400226e8:	94 10 20 00 	clr  %o2                                       
400226ec:	7f ff f4 d0 	call  4001fa2c <rtems_rfs_file_io_start>       
400226f0:	90 10 00 10 	mov  %l0, %o0                                  
    }                                                                 
                                                                      
    if (size > count)                                                 
      size = count;                                                   
                                                                      
    memcpy (rtems_rfs_file_data (file), data, size);                  
400226f4:	92 10 00 19 	mov  %i1, %o1                                  
  while (count)                                                       
  {                                                                   
    size_t size = count;                                              
                                                                      
    rc = rtems_rfs_file_io_start (file, &size, false);                
    if (rc)                                                           
400226f8:	80 a2 20 00 	cmp  %o0, 0                                    
400226fc:	02 bf ff e2 	be  40022684 <rtems_rfs_rtems_file_write+0xa4> 
40022700:	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);  
40022704:	40 00 05 0d 	call  40023b38 <__errno>                       
40022708:	a2 10 3f ff 	mov  -1, %l1                                   
4002270c:	fa 22 00 00 	st  %i5, [ %o0 ]                               
  }                                                                   
                                                                      
  if (write >= 0)                                                     
    iop->offset = pos + write;                                        
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
40022710:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
40022714:	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);                                     
40022718:	7f ff ed 8c 	call  4001dd48 <rtems_rfs_buffers_release>     
4002271c:	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);            
40022720:	7f ff ae 41 	call  4000e024 <rtems_semaphore_release>       
40022724:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40022728:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4002272c:	12 80 00 1b 	bne  40022798 <rtems_rfs_rtems_file_write+0x1b8><== NEVER TAKEN
40022730:	90 10 20 00 	clr  %o0                                       
                                                                      
  return write;                                                       
}                                                                     
40022734:	81 c7 e0 08 	ret                                            
40022738:	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) 
4002273c:	12 bf ff cc 	bne  4002266c <rtems_rfs_rtems_file_write+0x8c><== NEVER TAKEN
40022740:	a2 10 20 00 	clr  %l1                                       
40022744:	80 a0 c0 0a 	cmp  %g3, %o2                                  
40022748:	28 bf ff ca 	bleu,a   40022670 <rtems_rfs_rtems_file_write+0x90>
4002274c:	84 10 20 00 	clr  %g2                                       
40022750:	10 bf ff c3 	b  4002265c <rtems_rfs_rtems_file_write+0x7c>  
40022754:	c2 06 20 10 	ld  [ %i0 + 0x10 ], %g1                        
      write = rtems_rfs_rtems_error ("file-write: write close", rc);  
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  if (write >= 0)                                                     
40022758:	80 a4 60 00 	cmp  %l1, 0                                    
4002275c:	06 bf ff ed 	bl  40022710 <rtems_rfs_rtems_file_write+0x130><== NEVER TAKEN
40022760:	85 3c 60 1f 	sra  %l1, 0x1f, %g2                            
    iop->offset = pos + write;                                        
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
40022764:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  if (write >= 0)                                                     
    iop->offset = pos + write;                                        
40022768:	f8 1f bf f8 	ldd  [ %fp + -8 ], %i4                         
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
4002276c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
      break;                                                          
    }                                                                 
  }                                                                   
                                                                      
  if (write >= 0)                                                     
    iop->offset = pos + write;                                        
40022770:	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);            
40022774:	fa 02 20 80 	ld  [ %o0 + 0x80 ], %i5                        
40022778:	b4 40 80 1c 	addx  %g2, %i4, %i2                            
  rtems_rfs_buffers_release (fs);                                     
4002277c:	7f ff ed 73 	call  4001dd48 <rtems_rfs_buffers_release>     
40022780:	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);            
40022784:	7f ff ae 28 	call  4000e024 <rtems_semaphore_release>       
40022788:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
4002278c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40022790:	02 bf ff e9 	be  40022734 <rtems_rfs_rtems_file_write+0x154><== ALWAYS TAKEN
40022794:	90 10 20 00 	clr  %o0                                       
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40022798:	7f ff ca 43 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4002279c:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400227a0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400227a4:	02 bf ff e4 	be  40022734 <rtems_rfs_rtems_file_write+0x154><== NOT EXECUTED
400227a8:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
400227ac:	7f ff d8 99 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
400227b0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400227b4:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400227b8:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
400227bc:	40 00 0a 70 	call  4002517c <printf>                        <== NOT EXECUTED
400227c0:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400227c4:	30 bf ff dc 	b,a   40022734 <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))                      
400227c8:	7f ff ca 37 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400227cc:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400227d0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400227d4:	22 bf ff 90 	be,a   40022614 <rtems_rfs_rtems_file_write+0x34><== NOT EXECUTED
400227d8:	d2 04 20 1c 	ld  [ %l0 + 0x1c ], %o1                        <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
400227dc:	7f ff d8 8d 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
400227e0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400227e4:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400227e8:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
400227ec:	40 00 0a 64 	call  4002517c <printf>                        <== NOT EXECUTED
400227f0:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_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);                             
400227f4:	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;                                                  
400227f8:	c4 1e 20 08 	ldd  [ %i0 + 8 ], %g2                          <== NOT EXECUTED
400227fc:	d0 02 60 98 	ld  [ %o1 + 0x98 ], %o0                        <== NOT EXECUTED
40022800:	c4 3f bf f8 	std  %g2, [ %fp + -8 ]                         <== NOT EXECUTED
40022804:	7f ff e7 ed 	call  4001c7b8 <rtems_rfs_block_get_size>      <== NOT EXECUTED
40022808:	92 02 60 84 	add  %o1, 0x84, %o1                            <== NOT EXECUTED
4002280c:	86 10 00 09 	mov  %o1, %g3                                  <== NOT EXECUTED
  file_size = rtems_rfs_file_size (file);                             
  if (pos > file_size)                                                
40022810:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          <== NOT EXECUTED
40022814:	84 10 00 08 	mov  %o0, %g2                                  <== NOT EXECUTED
40022818:	80 a2 40 02 	cmp  %o1, %g2                                  <== NOT EXECUTED
4002281c:	08 bf ff 8a 	bleu  40022644 <rtems_rfs_rtems_file_write+0x64><== NOT EXECUTED
40022820:	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);                         
40022824:	7f ff f6 10 	call  40020064 <rtems_rfs_file_set_size>       
40022828:	90 10 00 10 	mov  %l0, %o0                                  
    if (rc)                                                           
    {                                                                 
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
4002282c:	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);                         
40022830:	ba 10 00 08 	mov  %o0, %i5                                  
    if (rc)                                                           
40022834:	80 a7 60 00 	cmp  %i5, 0                                    
40022838:	02 80 00 11 	be  4002287c <rtems_rfs_rtems_file_write+0x29c><== ALWAYS TAKEN
4002283c:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        
40022840:	7f ff ed 42 	call  4001dd48 <rtems_rfs_buffers_release>     <== NOT EXECUTED
40022844:	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);            
40022848:	7f ff ad f7 	call  4000e024 <rtems_semaphore_release>       <== NOT EXECUTED
4002284c:	d0 07 00 00 	ld  [ %i4 ], %o0                               <== NOT EXECUTED
  if (sc != RTEMS_SUCCESSFUL)                                         
40022850:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40022854:	12 80 00 1b 	bne  400228c0 <rtems_rfs_rtems_file_write+0x2e0><== NOT EXECUTED
40022858:	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);
4002285c:	40 00 04 b7 	call  40023b38 <__errno>                       <== NOT EXECUTED
40022860:	a2 10 3f ff 	mov  -1, %l1                                   <== NOT EXECUTED
40022864:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
    iop->offset = pos + write;                                        
                                                                      
  rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));                  
                                                                      
  return write;                                                       
}                                                                     
40022868:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4002286c:	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)                                                
40022870:	08 bf ff 78 	bleu  40022650 <rtems_rfs_rtems_file_write+0x70>
40022874:	80 a0 80 09 	cmp  %g2, %o1                                  
40022878:	30 bf ff eb 	b,a   40022824 <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);                              
4002287c:	d2 07 bf f8 	ld  [ %fp + -8 ], %o1                          
40022880:	d4 07 bf fc 	ld  [ %fp + -4 ], %o2                          
40022884:	7f ff e7 9e 	call  4001c6fc <rtems_rfs_block_get_bpos>      
40022888:	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)                                                       
4002288c:	10 bf ff 78 	b  4002266c <rtems_rfs_rtems_file_write+0x8c>  
40022890:	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);                       
40022894:	90 10 00 10 	mov  %l0, %o0                                  
40022898:	92 10 00 02 	mov  %g2, %o1                                  
4002289c:	94 10 00 03 	mov  %g3, %o2                                  
400228a0:	7f ff f5 ae 	call  4001ff58 <rtems_rfs_file_seek>           
400228a4:	96 07 bf f8 	add  %fp, -8, %o3                              
    if (rc)                                                           
400228a8:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400228ac:	02 bf ff 70 	be  4002266c <rtems_rfs_rtems_file_write+0x8c> <== ALWAYS TAKEN
400228b0:	a2 10 20 00 	clr  %l1                                       
    {                                                                 
      rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));              
400228b4:	c2 04 20 1c 	ld  [ %l0 + 0x1c ], %g1                        <== NOT EXECUTED
400228b8:	10 bf ff e2 	b  40022840 <rtems_rfs_rtems_file_write+0x260> <== NOT EXECUTED
400228bc:	d0 00 60 98 	ld  [ %g1 + 0x98 ], %o0                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
400228c0:	7f ff c9 f9 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400228c4:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
400228c8:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400228cc:	02 bf ff e4 	be  4002285c <rtems_rfs_rtems_file_write+0x27c><== NOT EXECUTED
400228d0:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
400228d4:	7f ff d8 4f 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
400228d8:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
400228dc:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
400228e0:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
400228e4:	40 00 0a 26 	call  4002517c <printf>                        <== NOT EXECUTED
400228e8:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
400228ec:	30 bf ff dc 	b,a   4002285c <rtems_rfs_rtems_file_write+0x27c><== NOT EXECUTED
                                                                      

40014744 <rtems_rfs_rtems_fstat>: } int rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc, struct stat* buf) {
40014744:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
40014748:	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);                  
4001474c:	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);  
40014750:	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);                  
40014754:	94 07 bf d8 	add  %fp, -40, %o2                             
40014758:	90 10 00 1d 	mov  %i5, %o0                                  
4001475c:	7f ff fb ab 	call  40013608 <rtems_rfs_inode_open>          
40014760:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40014764:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40014768:	12 80 00 6f 	bne  40014924 <rtems_rfs_rtems_fstat+0x1e0>    <== NEVER TAKEN
4001476c:	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))           
40014770:	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);                    
40014774:	c4 08 60 02 	ldub  [ %g1 + 2 ], %g2                         
40014778:	d0 08 60 03 	ldub  [ %g1 + 3 ], %o0                         
4001477c:	85 28 a0 08 	sll  %g2, 8, %g2                               
40014780:	07 00 00 08 	sethi  %hi(0x2000), %g3                        
40014784:	88 08 80 04 	and  %g2, %g4, %g4                             
40014788:	80 a1 00 03 	cmp  %g4, %g3                                  
4001478c:	02 80 00 4b 	be  400148b8 <rtems_rfs_rtems_fstat+0x174>     <== NEVER TAKEN
40014790:	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);                         
40014794:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
  buf->st_ino     = rtems_rfs_inode_ino (&inode);                     
  buf->st_mode    = rtems_rfs_rtems_mode (mode);                      
40014798:	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);                         
4001479c:	87 38 60 1f 	sra  %g1, 0x1f, %g3                            
400147a0:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]                           
  buf->st_ino     = rtems_rfs_inode_ino (&inode);                     
400147a4:	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);                         
400147a8:	c6 26 40 00 	st  %g3, [ %i1 ]                               
  buf->st_ino     = rtems_rfs_inode_ino (&inode);                     
400147ac:	c2 26 60 08 	st  %g1, [ %i1 + 8 ]                           
  buf->st_mode    = rtems_rfs_rtems_mode (mode);                      
400147b0:	40 00 02 3b 	call  4001509c <rtems_rfs_rtems_mode>          
400147b4:	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);                  
400147b8:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
400147bc:	d0 26 60 0c 	st  %o0, [ %i1 + 0xc ]                         
400147c0:	c6 08 60 01 	ldub  [ %g1 + 1 ], %g3                         
400147c4:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
  if (links == 0xffff)                                                
    links = 0;                                                        
400147c8:	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);                  
400147cc:	85 28 a0 08 	sll  %g2, 8, %g2                               
400147d0:	84 10 80 03 	or  %g2, %g3, %g2                              
  if (links == 0xffff)                                                
400147d4:	87 28 a0 10 	sll  %g2, 0x10, %g3                            
400147d8:	87 30 e0 10 	srl  %g3, 0x10, %g3                            
    links = 0;                                                        
400147dc:	86 39 00 03 	xnor  %g4, %g3, %g3                            
400147e0:	80 a0 00 03 	cmp  %g0, %g3                                  
400147e4:	86 60 20 00 	subx  %g0, 0, %g3                              
400147e8:	84 08 80 03 	and  %g2, %g3, %g2                             
  buf->st_nlink   = rtems_rfs_inode_get_links (&inode);               
400147ec:	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;          
400147f0:	c4 08 60 06 	ldub  [ %g1 + 6 ], %g2                         
400147f4:	c6 08 60 07 	ldub  [ %g1 + 7 ], %g3                         
400147f8:	85 28 a0 08 	sll  %g2, 8, %g2                               
400147fc:	84 10 80 03 	or  %g2, %g3, %g2                              
  buf->st_uid     = rtems_rfs_inode_get_uid (&inode);                 
40014800:	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;  
40014804:	c4 08 60 04 	ldub  [ %g1 + 4 ], %g2                         
40014808:	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));
4001480c:	d2 07 bf e0 	ld  [ %fp + -32 ], %o1                         
40014810:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40014814:	83 28 60 10 	sll  %g1, 0x10, %g1                            
40014818:	82 10 80 01 	or  %g2, %g1, %g1                              
4001481c:	83 30 60 10 	srl  %g1, 0x10, %g1                            
40014820:	90 10 00 1d 	mov  %i5, %o0                                  
40014824:	40 00 2e ec 	call  400203d4 <rtems_rfs_file_get_shared>     
40014828:	c2 36 60 14 	sth  %g1, [ %i1 + 0x14 ]                       
                                                                      
  if (shared)                                                         
4001482c:	92 92 20 00 	orcc  %o0, 0, %o1                              
40014830:	02 80 00 42 	be  40014938 <rtems_rfs_rtems_fstat+0x1f4>     
40014834:	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); 
40014838:	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);       
4001483c:	f8 02 60 8c 	ld  [ %o1 + 0x8c ], %i4                        
    buf->st_mtime   = rtems_rfs_file_shared_get_mtime (shared);       
40014840:	c8 02 60 90 	ld  [ %o1 + 0x90 ], %g4                        
    buf->st_ctime   = rtems_rfs_file_shared_get_ctime (shared);       
40014844:	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))                                       
40014848:	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); 
4001484c:	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);       
40014850:	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))                                       
40014854:	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);       
40014858:	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))                                       
4001485c:	84 08 80 01 	and  %g2, %g1, %g2                             
40014860:	03 00 00 28 	sethi  %hi(0xa000), %g1                        
40014864:	80 a0 80 01 	cmp  %g2, %g1                                  
40014868:	02 80 00 2b 	be  40014914 <rtems_rfs_rtems_fstat+0x1d0>     <== NEVER TAKEN
4001486c:	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);                
40014870:	90 10 00 1d 	mov  %i5, %o0                                  
40014874:	40 00 1f d1 	call  4001c7b8 <rtems_rfs_block_get_size>      
40014878:	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);     
4001487c:	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);                     
40014880:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40014884:	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);                     
40014888:	c2 26 60 40 	st  %g1, [ %i1 + 0x40 ]                        
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
4001488c:	92 07 bf d8 	add  %fp, -40, %o1                             
40014890:	7f ff fb d6 	call  400137e8 <rtems_rfs_inode_close>         
40014894:	b0 10 20 00 	clr  %i0                                       
  if (rc > 0)                                                         
40014898:	80 a2 20 00 	cmp  %o0, 0                                    
4001489c:	04 80 00 05 	ble  400148b0 <rtems_rfs_rtems_fstat+0x16c>    <== ALWAYS TAKEN
400148a0:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("stat: closing inode", rc);         
400148a4:	40 00 3c a5 	call  40023b38 <__errno>                       <== NOT EXECUTED
400148a8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400148ac:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
400148b0:	81 c7 e0 08 	ret                                            
400148b4:	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]);      
400148b8:	da 08 60 21 	ldub  [ %g1 + 0x21 ], %o5                      <== NOT EXECUTED
400148bc:	c8 08 60 20 	ldub  [ %g1 + 0x20 ], %g4                      <== NOT EXECUTED
400148c0:	de 08 60 23 	ldub  [ %g1 + 0x23 ], %o7                      <== NOT EXECUTED
400148c4:	f4 08 60 22 	ldub  [ %g1 + 0x22 ], %i2                      <== NOT EXECUTED
400148c8:	f6 08 60 1c 	ldub  [ %g1 + 0x1c ], %i3                      <== NOT EXECUTED
400148cc:	f0 08 60 1d 	ldub  [ %g1 + 0x1d ], %i0                      <== NOT EXECUTED
400148d0:	f8 08 60 1f 	ldub  [ %g1 + 0x1f ], %i4                      <== NOT EXECUTED
400148d4:	c6 08 60 1e 	ldub  [ %g1 + 0x1e ], %g3                      <== NOT EXECUTED
400148d8:	83 2b 60 10 	sll  %o5, 0x10, %g1                            <== NOT EXECUTED
400148dc:	89 29 20 18 	sll  %g4, 0x18, %g4                            <== NOT EXECUTED
400148e0:	b5 2e a0 08 	sll  %i2, 8, %i2                               <== NOT EXECUTED
400148e4:	88 11 00 01 	or  %g4, %g1, %g4                              <== NOT EXECUTED
400148e8:	b7 2e e0 18 	sll  %i3, 0x18, %i3                            <== NOT EXECUTED
400148ec:	88 11 00 0f 	or  %g4, %o7, %g4                              <== NOT EXECUTED
400148f0:	83 2e 20 10 	sll  %i0, 0x10, %g1                            <== NOT EXECUTED
400148f4:	88 11 00 1a 	or  %g4, %i2, %g4                              <== NOT EXECUTED
400148f8:	82 16 c0 01 	or  %i3, %g1, %g1                              <== NOT EXECUTED
400148fc:	87 28 e0 08 	sll  %g3, 8, %g3                               <== NOT EXECUTED
40014900:	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 =                                                    
40014904:	c8 26 60 1c 	st  %g4, [ %i1 + 0x1c ]                        <== NOT EXECUTED
40014908:	82 10 40 03 	or  %g1, %g3, %g1                              <== NOT EXECUTED
4001490c:	10 bf ff a2 	b  40014794 <rtems_rfs_rtems_fstat+0x50>       <== NOT EXECUTED
40014910:	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); 
40014914:	c2 12 60 8a 	lduh  [ %o1 + 0x8a ], %g1                      <== NOT EXECUTED
40014918:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            <== NOT EXECUTED
4001491c:	10 bf ff d9 	b  40014880 <rtems_rfs_rtems_fstat+0x13c>      <== NOT EXECUTED
40014920:	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);         
40014924:	40 00 3c 85 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014928:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001492c:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40014930:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014934:	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))                                       
40014938:	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);                   
4001493c:	f8 08 60 13 	ldub  [ %g1 + 0x13 ], %i4                      
40014940:	c4 08 60 10 	ldub  [ %g1 + 0x10 ], %g2                      
40014944:	f6 08 60 11 	ldub  [ %g1 + 0x11 ], %i3                      
40014948:	c8 08 60 12 	ldub  [ %g1 + 0x12 ], %g4                      
4001494c:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
40014950:	89 29 20 08 	sll  %g4, 8, %g4                               
40014954:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40014958:	84 10 80 1b 	or  %g2, %i3, %g2                              
4001495c:	84 10 80 1c 	or  %g2, %i4, %g2                              
40014960:	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);             
40014964:	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);                   
40014968:	f8 08 60 17 	ldub  [ %g1 + 0x17 ], %i4                      
4001496c:	c4 08 60 14 	ldub  [ %g1 + 0x14 ], %g2                      
40014970:	f6 08 60 15 	ldub  [ %g1 + 0x15 ], %i3                      
40014974:	c8 08 60 16 	ldub  [ %g1 + 0x16 ], %g4                      
40014978:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
4001497c:	89 29 20 08 	sll  %g4, 8, %g4                               
40014980:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40014984:	84 10 80 1b 	or  %g2, %i3, %g2                              
40014988:	84 10 80 1c 	or  %g2, %i4, %g2                              
4001498c:	84 10 80 04 	or  %g2, %g4, %g2                              
    buf->st_mtime   = rtems_rfs_inode_get_mtime (&inode);             
40014990:	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);                   
40014994:	f8 08 60 1b 	ldub  [ %g1 + 0x1b ], %i4                      
40014998:	c4 08 60 18 	ldub  [ %g1 + 0x18 ], %g2                      
4001499c:	f6 08 60 19 	ldub  [ %g1 + 0x19 ], %i3                      
400149a0:	c8 08 60 1a 	ldub  [ %g1 + 0x1a ], %g4                      
400149a4:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
400149a8:	89 29 20 08 	sll  %g4, 8, %g4                               
400149ac:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
400149b0:	84 10 80 1b 	or  %g2, %i3, %g2                              
400149b4:	84 10 80 1c 	or  %g2, %i4, %g2                              
400149b8:	84 10 80 04 	or  %g2, %g4, %g2                              
    buf->st_ctime   = rtems_rfs_inode_get_ctime (&inode);             
400149bc:	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);             
400149c0:	c4 08 60 0c 	ldub  [ %g1 + 0xc ], %g2                       
400149c4:	f6 08 60 0d 	ldub  [ %g1 + 0xd ], %i3                       
400149c8:	f8 08 60 0f 	ldub  [ %g1 + 0xf ], %i4                       
400149cc:	c8 08 60 0e 	ldub  [ %g1 + 0xe ], %g4                       
400149d0:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
400149d4:	b7 2e e0 10 	sll  %i3, 0x10, %i3                            
400149d8:	89 29 20 08 	sll  %g4, 8, %g4                               
400149dc:	84 10 80 1b 	or  %g2, %i3, %g2                              
400149e0:	84 10 80 1c 	or  %g2, %i4, %g2                              
400149e4:	84 10 80 04 	or  %g2, %g4, %g2                              
    buf->st_blocks  = rtems_rfs_inode_get_block_count (&inode);       
400149e8:	c4 26 60 44 	st  %g2, [ %i1 + 0x44 ]                        
                                                                      
    if (S_ISLNK (buf->st_mode))                                       
400149ec:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
400149f0:	86 08 c0 02 	and  %g3, %g2, %g3                             
400149f4:	05 00 00 28 	sethi  %hi(0xa000), %g2                        
400149f8:	80 a0 c0 02 	cmp  %g3, %g2                                  
400149fc:	12 80 00 09 	bne  40014a20 <rtems_rfs_rtems_fstat+0x2dc>    
40014a00:	90 10 00 1d 	mov  %i5, %o0                                  
      buf->st_size = rtems_rfs_inode_get_block_offset (&inode);       
40014a04:	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);            
40014a08:	c6 08 60 0a 	ldub  [ %g1 + 0xa ], %g3                       
40014a0c:	c0 26 60 20 	clr  [ %i1 + 0x20 ]                            
40014a10:	83 28 e0 08 	sll  %g3, 8, %g1                               
40014a14:	82 10 80 01 	or  %g2, %g1, %g1                              
40014a18:	10 bf ff 9a 	b  40014880 <rtems_rfs_rtems_fstat+0x13c>      
40014a1c:	c2 26 60 24 	st  %g1, [ %i1 + 0x24 ]                        
    else                                                              
      buf->st_size = rtems_rfs_inode_get_size (fs, &inode);           
40014a20:	7f ff fd 2c 	call  40013ed0 <rtems_rfs_inode_get_size>      
40014a24:	92 07 bf d8 	add  %fp, -40, %o1                             
40014a28:	10 bf ff 96 	b  40014880 <rtems_rfs_rtems_fstat+0x13c>      
40014a2c:	d0 3e 60 20 	std  %o0, [ %i1 + 0x20 ]                       
                                                                      

40014c9c <rtems_rfs_rtems_initialise>: */ int rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry, const void* data) {
40014c9c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int                      rc;                                        
                                                                      
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
40014ca0:	a2 10 20 05 	mov  5, %l1                                    
40014ca4:	80 a6 60 00 	cmp  %i1, 0                                    
40014ca8:	02 80 00 1f 	be  40014d24 <rtems_rfs_rtems_initialise+0x88> <== ALWAYS TAKEN
40014cac:	ba 10 20 00 	clr  %i5                                       
  {                                                                   
    printf ("options=%s\n", options);                                 
40014cb0:	37 10 00 dc 	sethi  %hi(0x40037000), %i3                    <== NOT EXECUTED
    if (strncmp (options, "hold-bitmaps",                             
40014cb4:	39 10 00 dc 	sethi  %hi(0x40037000), %i4                    <== NOT EXECUTED
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
40014cb8:	35 10 00 dc 	sethi  %hi(0x40037000), %i2                    <== NOT EXECUTED
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
    else if (strncmp (options, "max-held-bufs",                       
40014cbc:	21 10 00 dc 	sethi  %hi(0x40037000), %l0                    <== NOT EXECUTED
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
  {                                                                   
    printf ("options=%s\n", options);                                 
40014cc0:	b6 16 e1 18 	or  %i3, 0x118, %i3                            <== NOT EXECUTED
    if (strncmp (options, "hold-bitmaps",                             
40014cc4:	b8 17 21 28 	or  %i4, 0x128, %i4                            <== NOT EXECUTED
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
    else if (strncmp (options, "no-local-cache",                      
40014cc8:	b4 16 a1 38 	or  %i2, 0x138, %i2                            <== NOT EXECUTED
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
    else if (strncmp (options, "max-held-bufs",                       
40014ccc:	a0 14 21 48 	or  %l0, 0x148, %l0                            <== NOT EXECUTED
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
  {                                                                   
    printf ("options=%s\n", options);                                 
40014cd0:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40014cd4:	40 00 41 2a 	call  4002517c <printf>                        <== NOT EXECUTED
40014cd8:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
    if (strncmp (options, "hold-bitmaps",                             
40014cdc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40014ce0:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40014ce4:	40 00 45 c9 	call  40026408 <strncmp>                       <== NOT EXECUTED
40014ce8:	94 10 20 0c 	mov  0xc, %o2                                  <== NOT EXECUTED
40014cec:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40014cf0:	12 80 00 1e 	bne  40014d68 <rtems_rfs_rtems_initialise+0xcc><== NOT EXECUTED
40014cf4:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
                 sizeof ("hold-bitmaps") - 1) == 0)                   
      flags |= RTEMS_RFS_FS_BITMAPS_HOLD;                             
40014cf8:	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, ',');                                  
40014cfc:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40014d00:	40 00 43 48 	call  40025a20 <strchr>                        <== NOT EXECUTED
40014d04:	92 10 20 2c 	mov  0x2c, %o1                                 <== NOT EXECUTED
    if (options)                                                      
40014d08:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40014d0c:	02 80 00 06 	be  40014d24 <rtems_rfs_rtems_initialise+0x88> <== NOT EXECUTED
40014d10:	01 00 00 00 	nop                                            <== NOT EXECUTED
    {                                                                 
      ++options;                                                      
      if (*options == '\0')                                           
40014d14:	c2 4a 20 01 	ldsb  [ %o0 + 1 ], %g1                         <== NOT EXECUTED
40014d18:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40014d1c:	12 80 00 1b 	bne  40014d88 <rtems_rfs_rtems_initialise+0xec><== NOT EXECUTED
40014d20:	b2 82 20 01 	addcc  %o0, 1, %i1                             <== NOT EXECUTED
        options = NULL;                                               
    }                                                                 
  }                                                                   
                                                                      
  rtems = malloc (sizeof (rtems_rfs_rtems_private));                  
40014d24:	7f ff d2 9e 	call  4000979c <malloc>                        
40014d28:	90 10 20 04 	mov  4, %o0                                    
  if (!rtems)                                                         
40014d2c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40014d30:	02 80 00 75 	be  40014f04 <rtems_rfs_rtems_initialise+0x268><== NEVER TAKEN
40014d34:	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);                       
40014d38:	40 00 32 a5 	call  400217cc <rtems_rfs_mutex_create>        
40014d3c:	c0 27 00 00 	clr  [ %i4 ]                                   
  if (rc > 0)                                                         
40014d40:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40014d44:	24 80 00 1f 	ble,a   40014dc0 <rtems_rfs_rtems_initialise+0x124><== ALWAYS TAKEN
40014d48:	d0 07 00 00 	ld  [ %i4 ], %o0                               
  {                                                                   
    free (rtems);                                                     
40014d4c:	7f ff d0 f7 	call  40009128 <free>                          <== NOT EXECUTED
40014d50:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
40014d54:	40 00 3b 79 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014d58:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014d5c:	f6 22 00 00 	st  %i3, [ %o0 ]                               <== NOT EXECUTED
40014d60:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014d64:	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",                      
40014d68:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40014d6c:	40 00 45 a7 	call  40026408 <strncmp>                       <== NOT EXECUTED
40014d70:	94 10 20 0e 	mov  0xe, %o2                                  <== NOT EXECUTED
40014d74:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40014d78:	12 80 00 07 	bne  40014d94 <rtems_rfs_rtems_initialise+0xf8><== NOT EXECUTED
40014d7c:	92 10 00 10 	mov  %l0, %o1                                  <== NOT EXECUTED
                      sizeof ("no-local-cache") - 1) == 0)            
      flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;                           
40014d80:	10 bf ff df 	b  40014cfc <rtems_rfs_rtems_initialise+0x60>  <== NOT EXECUTED
40014d84:	ba 17 60 02 	or  %i5, 2, %i5                                <== NOT EXECUTED
  int                      rc;                                        
                                                                      
  /*                                                                  
   * Parse the options the user specifiies.                           
   */                                                                 
  while (options)                                                     
40014d88:	12 bf ff d3 	bne  40014cd4 <rtems_rfs_rtems_initialise+0x38><== NOT EXECUTED
40014d8c:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40014d90:	30 bf ff e5 	b,a   40014d24 <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",                       
40014d94:	90 10 00 19 	mov  %i1, %o0                                  <== NOT EXECUTED
40014d98:	40 00 45 9c 	call  40026408 <strncmp>                       <== NOT EXECUTED
40014d9c:	94 10 20 0d 	mov  0xd, %o2                                  <== NOT EXECUTED
40014da0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40014da4:	12 80 00 2c 	bne  40014e54 <rtems_rfs_rtems_initialise+0x1b8><== NOT EXECUTED
40014da8:	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);
40014dac:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40014db0:	40 00 46 75 	call  40026784 <strtoul>                       <== NOT EXECUTED
40014db4:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
40014db8:	10 bf ff d1 	b  40014cfc <rtems_rfs_rtems_initialise+0x60>  <== NOT EXECUTED
40014dbc:	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);
40014dc0:	92 10 20 00 	clr  %o1                                       
40014dc4:	7f ff e4 49 	call  4000dee8 <rtems_semaphore_obtain>        
40014dc8:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
40014dcc:	b6 92 20 00 	orcc  %o0, 0, %i3                              
40014dd0:	12 80 00 11 	bne  40014e14 <rtems_rfs_rtems_initialise+0x178><== NEVER TAKEN
40014dd4:	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);
40014dd8:	d0 06 20 38 	ld  [ %i0 + 0x38 ], %o0                        
40014ddc:	92 10 00 1c 	mov  %i4, %o1                                  
40014de0:	96 10 00 11 	mov  %l1, %o3                                  
40014de4:	40 00 2d a1 	call  40020468 <rtems_rfs_fs_open>             
40014de8:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (rc)                                                             
40014dec:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40014df0:	02 80 00 1f 	be  40014e6c <rtems_rfs_rtems_initialise+0x1d0><== ALWAYS TAKEN
40014df4:	d0 07 bf fc 	ld  [ %fp + -4 ], %o0                          
  {                                                                   
    free (rtems);                                                     
40014df8:	7f ff d0 cc 	call  40009128 <free>                          <== NOT EXECUTED
40014dfc:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: open", rc);            
40014e00:	40 00 3b 4e 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014e04:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014e08:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
40014e0c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014e10:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40014e14:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40014e18:	40 00 00 a3 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40014e1c:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40014e20:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40014e24:	12 80 00 25 	bne  40014eb8 <rtems_rfs_rtems_initialise+0x21c><== NOT EXECUTED
40014e28:	01 00 00 00 	nop                                            <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_mutex_lock (&rtems->access);                         
  if (rc > 0)                                                         
  {                                                                   
    rtems_rfs_mutex_destroy (&rtems->access);                         
40014e2c:	40 00 32 83 	call  40021838 <rtems_rfs_mutex_destroy>       <== NOT EXECUTED
40014e30:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    free (rtems);                                                     
40014e34:	7f ff d0 bd 	call  40009128 <free>                          <== NOT EXECUTED
40014e38:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("initialise: cannot lock access  mutex", rc);
40014e3c:	40 00 3b 3f 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014e40:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014e44:	82 10 20 05 	mov  5, %g1                                    <== NOT EXECUTED
40014e48:	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;                                                           
}                                                                     
40014e4c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014e50:	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);
40014e54:	40 00 3b 39 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014e58:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014e5c:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40014e60:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40014e64:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014e68:	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;
40014e6c:	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;        
40014e70:	05 10 00 dc 	sethi  %hi(0x40037000), %g2                    
40014e74:	84 10 a1 80 	or  %g2, 0x180, %g2	! 40037180 <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);            
40014e78:	fa 02 20 80 	ld  [ %o0 + 0x80 ], %i5                        
  {                                                                   
    free (rtems);                                                     
    return rtems_rfs_rtems_error ("initialise: open", rc);            
  }                                                                   
                                                                      
  mt_entry->fs_info                          = fs;                    
40014e7c:	d0 26 20 08 	st  %o0, [ %i0 + 8 ]                           
  mt_entry->ops                              = &rtems_rfs_ops;        
40014e80:	c4 26 20 0c 	st  %g2, [ %i0 + 0xc ]                         
  mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
40014e84:	84 10 20 01 	mov  1, %g2                                    
40014e88:	c4 20 60 08 	st  %g2, [ %g1 + 8 ]                           
  mt_entry->mt_fs_root->location.handlers    = &rtems_rfs_rtems_dir_handlers;
40014e8c:	05 10 00 e5 	sethi  %hi(0x40039400), %g2                    
40014e90:	84 10 a0 c8 	or  %g2, 0xc8, %g2	! 400394c8 <rtems_rfs_rtems_dir_handlers>
  rtems_rfs_buffers_release (fs);                                     
40014e94:	40 00 23 ad 	call  4001dd48 <rtems_rfs_buffers_release>     
40014e98:	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);            
40014e9c:	7f ff e4 62 	call  4000e024 <rtems_semaphore_release>       
40014ea0:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40014ea4:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40014ea8:	12 80 00 0b 	bne  40014ed4 <rtems_rfs_rtems_initialise+0x238><== NEVER TAKEN
40014eac:	90 10 20 00 	clr  %o0                                       
                                                                      
  rtems_rfs_rtems_unlock (fs);                                        
                                                                      
  return 0;                                                           
40014eb0:	81 c7 e0 08 	ret                                            
40014eb4:	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",                
40014eb8:	40 00 0e d6 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40014ebc:	90 10 00 1b 	mov  %i3, %o0                                  <== NOT EXECUTED
40014ec0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40014ec4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40014ec8:	40 00 40 ad 	call  4002517c <printf>                        <== NOT EXECUTED
40014ecc:	90 12 21 58 	or  %o0, 0x158, %o0	! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
40014ed0:	30 bf ff d7 	b,a   40014e2c <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))                      
40014ed4:	40 00 00 74 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40014ed8:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40014edc:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40014ee0:	02 bf ff f4 	be  40014eb0 <rtems_rfs_rtems_initialise+0x214><== NOT EXECUTED
40014ee4:	01 00 00 00 	nop                                            <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40014ee8:	40 00 0e ca 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40014eec:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40014ef0:	92 10 00 08 	mov  %o0, %o1                                  <== NOT EXECUTED
40014ef4:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40014ef8:	40 00 40 a1 	call  4002517c <printf>                        <== NOT EXECUTED
40014efc:	90 12 20 f0 	or  %o0, 0xf0, %o0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40014f00:	30 bf ff ec 	b,a   40014eb0 <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);  
40014f04:	40 00 3b 0d 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014f08:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014f0c:	82 10 20 0c 	mov  0xc, %g1                                  <== NOT EXECUTED
40014f10:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40014f14:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014f18:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40014048 <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) {
40014048:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
4001404c:	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);     
40014050:	d6 06 20 08 	ld  [ %i0 + 8 ], %o3                           
40014054:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
40014058:	d8 06 60 08 	ld  [ %i1 + 8 ], %o4                           
4001405c:	92 10 00 1a 	mov  %i2, %o1                                  
40014060:	94 10 00 1b 	mov  %i3, %o2                                  
40014064:	9a 10 20 00 	clr  %o5                                       
40014068:	40 00 33 4c 	call  40020d98 <rtems_rfs_link>                
4001406c:	b0 10 20 00 	clr  %i0                                       
  if (rc)                                                             
40014070:	80 a2 20 00 	cmp  %o0, 0                                    
40014074:	02 80 00 05 	be  40014088 <rtems_rfs_rtems_link+0x40>       <== ALWAYS TAKEN
40014078:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("link: linking", rc);               
4001407c:	40 00 3e af 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014080:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014084:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
	}                                                                    
                                                                      
                                                                      
	return 0;                                                            
}                                                                     
40014088:	81 c7 e0 08 	ret                                            
4001408c:	81 e8 00 00 	restore                                        
                                                                      

40014f1c <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 ) {
40014f1c:	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);            
40014f20:	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);
40014f24:	92 10 20 00 	clr  %o1                                       
  /* FIXME: Return value? */                                          
  rtems_rfs_fs_close(fs);                                             
                                                                      
  rtems_rfs_mutex_destroy (&rtems->access);                           
  free (rtems);                                                       
}                                                                     
40014f28:	c2 00 60 80 	ld  [ %g1 + 0x80 ], %g1                        
40014f2c:	94 10 20 00 	clr  %o2                                       
40014f30:	7f ff e3 ee 	call  4000dee8 <rtems_semaphore_obtain>        
40014f34:	d0 00 40 00 	ld  [ %g1 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40014f38:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40014f3c:	12 80 00 04 	bne  40014f4c <rtems_rfs_rtems_lock_by_mt_entry+0x30><== NEVER TAKEN
40014f40:	90 10 20 00 	clr  %o0                                       
40014f44:	81 c7 e0 08 	ret                                            
40014f48:	81 e8 00 00 	restore                                        
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40014f4c:	40 00 00 56 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40014f50:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40014f54:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40014f58:	02 bf ff fb 	be  40014f44 <rtems_rfs_rtems_lock_by_mt_entry+0x28><== NOT EXECUTED
40014f5c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: obtain failed: %s\n",                
40014f60:	40 00 0e ac 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40014f64:	31 10 00 dc 	sethi  %hi(0x40037000), %i0                    <== NOT EXECUTED
40014f68:	b0 16 21 58 	or  %i0, 0x158, %i0	! 40037158 <_CPU_Trap_slot_template+0xc70><== NOT EXECUTED
40014f6c:	40 00 40 84 	call  4002517c <printf>                        <== NOT EXECUTED
40014f70:	93 e8 00 08 	restore  %g0, %o0, %o1                         <== NOT EXECUTED
                                                                      

4001451c <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) {
4001451c:	9d e3 bf 60 	save  %sp, -160, %sp                           
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (parentloc);
40014520:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  rtems_rfs_ino           parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
40014524:	e0 06 20 08 	ld  [ %i0 + 8 ], %l0                           
  uid_t                   uid;                                        
  gid_t                   gid;                                        
  int                     rc;                                         
                                                                      
#if defined(RTEMS_POSIX_API)                                          
  uid = geteuid ();                                                   
40014528:	40 00 12 0f 	call  40018d64 <geteuid>                       
4001452c:	f0 00 60 08 	ld  [ %g1 + 8 ], %i0                           
  gid = getegid ();                                                   
40014530:	40 00 12 09 	call  40018d54 <getegid>                       
40014534:	a2 10 00 08 	mov  %o0, %l1                                  
40014538:	a4 10 00 08 	mov  %o0, %l2                                  
#else                                                                 
  uid = 0;                                                            
  gid = 0;                                                            
#endif                                                                
                                                                      
  rc = rtems_rfs_inode_create (fs, parent, name, namelen,             
4001453c:	40 00 02 d5 	call  40015090 <rtems_rfs_rtems_imode>         
40014540:	90 10 00 1b 	mov  %i3, %o0                                  
40014544:	82 07 bf d4 	add  %fp, -44, %g1                             
40014548:	99 2a 20 10 	sll  %o0, 0x10, %o4                            
4001454c:	96 10 00 1a 	mov  %i2, %o3                                  
40014550:	a3 2c 60 10 	sll  %l1, 0x10, %l1                            
40014554:	a5 2c a0 10 	sll  %l2, 0x10, %l2                            
40014558:	a3 34 60 10 	srl  %l1, 0x10, %l1                            
4001455c:	a5 34 a0 10 	srl  %l2, 0x10, %l2                            
40014560:	e2 23 a0 5c 	st  %l1, [ %sp + 0x5c ]                        
40014564:	e4 23 a0 60 	st  %l2, [ %sp + 0x60 ]                        
40014568:	90 10 00 18 	mov  %i0, %o0                                  
4001456c:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
40014570:	92 10 00 10 	mov  %l0, %o1                                  
40014574:	94 10 00 19 	mov  %i1, %o2                                  
40014578:	99 33 20 10 	srl  %o4, 0x10, %o4                            
4001457c:	7f ff fd 75 	call  40013b50 <rtems_rfs_inode_create>        
40014580:	9a 10 20 01 	mov  1, %o5                                    
                               rtems_rfs_rtems_imode (mode),          
                               1, uid, gid, &ino);                    
  if (rc > 0)                                                         
40014584:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40014588:	04 80 00 07 	ble  400145a4 <rtems_rfs_rtems_mknod+0x88>     
4001458c:	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);           
40014590:	40 00 3d 6a 	call  40023b38 <__errno>                       
40014594:	b0 10 3f ff 	mov  -1, %i0                                   
40014598:	f4 22 00 00 	st  %i2, [ %o0 ]                               
4001459c:	81 c7 e0 08 	ret                                            
400145a0:	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);                  
400145a4:	90 10 00 18 	mov  %i0, %o0                                  
400145a8:	94 07 bf d8 	add  %fp, -40, %o2                             
400145ac:	7f ff fc 17 	call  40013608 <rtems_rfs_inode_open>          
400145b0:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
400145b4:	b4 92 20 00 	orcc  %o0, 0, %i2                              
400145b8:	14 bf ff f6 	bg  40014590 <rtems_rfs_rtems_mknod+0x74>      <== NEVER TAKEN
400145bc:	03 00 00 3c 	sethi  %hi(0xf000), %g1                        
  {                                                                   
    return rtems_rfs_rtems_error ("mknod: inode open", rc);           
  }                                                                   
                                                                      
  if (S_ISDIR(mode) || S_ISREG(mode))                                 
400145c0:	05 00 00 20 	sethi  %hi(0x8000), %g2                        
400145c4:	82 0e c0 01 	and  %i3, %g1, %g1                             
400145c8:	80 a0 40 02 	cmp  %g1, %g2                                  
400145cc:	02 80 00 1a 	be  40014634 <rtems_rfs_rtems_mknod+0x118>     
400145d0:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
400145d4:	80 a0 40 02 	cmp  %g1, %g2                                  
400145d8:	02 80 00 17 	be  40014634 <rtems_rfs_rtems_mknod+0x118>     <== ALWAYS TAKEN
400145dc:	03 00 00 2c 	sethi  %hi(0xb000), %g1                        
  {                                                                   
  }                                                                   
  else if (S_ISCHR (mode) || S_ISBLK (mode))                          
400145e0:	b6 0e c0 01 	and  %i3, %g1, %i3                             <== NOT EXECUTED
400145e4:	03 00 00 08 	sethi  %hi(0x2000), %g1                        <== NOT EXECUTED
400145e8:	80 a6 c0 01 	cmp  %i3, %g1                                  <== NOT EXECUTED
400145ec:	12 80 00 1e 	bne  40014664 <rtems_rfs_rtems_mknod+0x148>    <== NOT EXECUTED
400145f0:	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);       
400145f4:	b3 37 20 18 	srl  %i4, 0x18, %i1                            <== NOT EXECUTED
400145f8:	b5 37 20 10 	srl  %i4, 0x10, %i2                            <== NOT EXECUTED
400145fc:	b7 37 20 08 	srl  %i4, 8, %i3                               <== NOT EXECUTED
40014600:	89 37 60 18 	srl  %i5, 0x18, %g4                            <== NOT EXECUTED
40014604:	87 37 60 10 	srl  %i5, 0x10, %g3                            <== NOT EXECUTED
40014608:	85 37 60 08 	srl  %i5, 8, %g2                               <== NOT EXECUTED
4001460c:	f8 28 60 1f 	stb  %i4, [ %g1 + 0x1f ]                       <== NOT EXECUTED
40014610:	f2 28 60 1c 	stb  %i1, [ %g1 + 0x1c ]                       <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40014614:	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);       
40014618:	f4 28 60 1d 	stb  %i2, [ %g1 + 0x1d ]                       <== NOT EXECUTED
4001461c:	f6 28 60 1e 	stb  %i3, [ %g1 + 0x1e ]                       <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40014620:	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);       
40014624:	c8 28 60 20 	stb  %g4, [ %g1 + 0x20 ]                       <== NOT EXECUTED
40014628:	c6 28 60 21 	stb  %g3, [ %g1 + 0x21 ]                       <== NOT EXECUTED
4001462c:	c4 28 60 22 	stb  %g2, [ %g1 + 0x22 ]                       <== NOT EXECUTED
40014630:	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);                            
40014634:	90 10 00 18 	mov  %i0, %o0                                  
40014638:	92 07 bf d8 	add  %fp, -40, %o1                             
4001463c:	7f ff fc 6b 	call  400137e8 <rtems_rfs_inode_close>         
40014640:	b0 10 20 00 	clr  %i0                                       
  if (rc > 0)                                                         
40014644:	80 a2 20 00 	cmp  %o0, 0                                    
40014648:	04 bf ff d5 	ble  4001459c <rtems_rfs_rtems_mknod+0x80>     <== ALWAYS TAKEN
4001464c:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("mknod: closing inode", rc);        
40014650:	40 00 3d 3a 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014654:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014658:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
4001465c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014660:	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);                               
40014664:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40014668:	7f ff fc 60 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
4001466c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);         
40014670:	40 00 3d 32 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014674:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014678:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4001467c:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
40014680:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014684:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

400144b0 <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) {
400144b0:	9d e3 bf 78 	save  %sp, -136, %sp                           
  rtems_rfs_file_system*        fs = rtems_rfs_rtems_pathloc_dev (pathloc);
400144b4:	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);                  
400144b8:	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);
400144bc:	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);                  
400144c0:	94 07 bf d8 	add  %fp, -40, %o2                             
400144c4:	90 10 00 1c 	mov  %i4, %o0                                  
400144c8:	7f ff fc 50 	call  40013608 <rtems_rfs_inode_open>          
400144cc:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
400144d0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400144d4:	04 80 00 07 	ble  400144f0 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
400144d8:	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);    
400144dc:	40 00 3d 97 	call  40023b38 <__errno>                       <== NOT EXECUTED
400144e0:	b0 10 3f ff 	mov  -1, %i0	! ffffffff <LEON_REG+0x7fffffff>  <== NOT EXECUTED
400144e4:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
400144e8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400144ec:	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);                 
400144f0:	7f ff fe 90 	call  40013f30 <rtems_rfs_rtems_node_type_by_inode>
400144f4:	90 07 bf d8 	add  %fp, -40, %o0                             
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
400144f8:	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);                 
400144fc:	b0 10 00 08 	mov  %o0, %i0                                  
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40014500:	7f ff fc ba 	call  400137e8 <rtems_rfs_inode_close>         
40014504:	90 10 00 1c 	mov  %i4, %o0                                  
  if (rc > 0)                                                         
40014508:	ba 92 20 00 	orcc  %o0, 0, %i5                              
4001450c:	14 bf ff f4 	bg  400144dc <rtems_rfs_rtems_node_type+0x2c>  <== NEVER TAKEN
40014510:	01 00 00 00 	nop                                            
  {                                                                   
    return rtems_rfs_rtems_error ("node_type: closing inode", rc);    
  }                                                                   
                                                                      
  return type;                                                        
}                                                                     
40014514:	81 c7 e0 08 	ret                                            
40014518:	81 e8 00 00 	restore                                        
                                                                      

40014160 <rtems_rfs_rtems_readlink>: static ssize_t rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc, char* buf, size_t bufsize) {
40014160:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (pathloc); 
40014164:	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);       
40014168:	d2 06 20 08 	ld  [ %i0 + 8 ], %o1                           
4001416c:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
40014170:	94 10 00 19 	mov  %i1, %o2                                  
40014174:	96 10 00 1a 	mov  %i2, %o3                                  
40014178:	40 00 35 23 	call  40021604 <rtems_rfs_symlink_read>        
4001417c:	98 07 bf fc 	add  %fp, -4, %o4                              
  if (rc)                                                             
  {                                                                   
    return rtems_rfs_rtems_error ("readlink: reading link", rc);      
  }                                                                   
                                                                      
  return (ssize_t) length;                                            
40014180:	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)                                                             
40014184:	80 a2 20 00 	cmp  %o0, 0                                    
40014188:	02 80 00 05 	be  4001419c <rtems_rfs_rtems_readlink+0x3c>   <== ALWAYS TAKEN
4001418c:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("readlink: reading link", rc);      
40014190:	40 00 3e 6a 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014194:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014198:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return (ssize_t) length;                                            
}                                                                     
4001419c:	81 c7 e0 08 	ret                                            
400141a0:	81 e8 00 00 	restore                                        
                                                                      

40014090 <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) {
40014090:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  rtems_rfs_file_system*  fs = rtems_rfs_rtems_pathloc_dev (old_loc); 
40014094:	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);                   
40014098:	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); 
4001409c:	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);
400140a0:	d6 06 a0 08 	ld  [ %i2 + 8 ], %o3                           <== NOT EXECUTED
400140a4:	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);      
400140a8:	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);                  
400140ac:	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);
400140b0:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
400140b4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
400140b8:	98 10 00 1d 	mov  %i5, %o4                                  <== NOT EXECUTED
400140bc:	40 00 33 37 	call  40020d98 <rtems_rfs_link>                <== NOT EXECUTED
400140c0:	9a 10 20 01 	mov  1, %o5                                    <== NOT EXECUTED
  if (rc)                                                             
400140c4:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
400140c8:	02 80 00 07 	be  400140e4 <rtems_rfs_rtems_rename+0x54>     <== NOT EXECUTED
400140cc:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("rename: linking", rc);             
400140d0:	40 00 3e 9a 	call  40023b38 <__errno>                       <== NOT EXECUTED
400140d4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400140d8:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
400140dc:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400140e0:	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,                   
400140e4:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
400140e8:	90 10 00 10 	mov  %l0, %o0                                  <== NOT EXECUTED
400140ec:	96 10 00 1a 	mov  %i2, %o3                                  <== NOT EXECUTED
400140f0:	98 10 20 02 	mov  2, %o4                                    <== NOT EXECUTED
400140f4:	40 00 33 9d 	call  40020f68 <rtems_rfs_unlink>              <== NOT EXECUTED
400140f8:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
                         rtems_rfs_unlink_dir_allowed);               
  if (rc)                                                             
400140fc:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40014100:	02 bf ff f7 	be  400140dc <rtems_rfs_rtems_rename+0x4c>     <== NOT EXECUTED
40014104:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("rename: unlinking", rc);           
40014108:	40 00 3e 8c 	call  40023b38 <__errno>                       <== NOT EXECUTED
4001410c:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014110:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40014114:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014118:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40014fa8 <rtems_rfs_rtems_set_handlers>: */ bool rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc, rtems_rfs_inode_handle* inode) {
40014fa8:	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);                    
40014fac:	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))                                       
40014fb0:	07 00 00 10 	sethi  %hi(0x4000), %g3                        
40014fb4:	c2 08 a0 02 	ldub  [ %g2 + 2 ], %g1                         
40014fb8:	c4 08 a0 03 	ldub  [ %g2 + 3 ], %g2                         
40014fbc:	83 28 60 08 	sll  %g1, 8, %g1                               
40014fc0:	82 10 40 02 	or  %g1, %g2, %g1                              
40014fc4:	05 00 00 3c 	sethi  %hi(0xf000), %g2                        
40014fc8:	84 08 40 02 	and  %g1, %g2, %g2                             
40014fcc:	80 a0 80 03 	cmp  %g2, %g3                                  
40014fd0:	02 80 00 1d 	be  40015044 <rtems_rfs_rtems_set_handlers+0x9c>
40014fd4:	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))       
40014fd8:	09 00 00 2c 	sethi  %hi(0xb000), %g4                        
40014fdc:	07 00 00 08 	sethi  %hi(0x2000), %g3                        
40014fe0:	88 08 40 04 	and  %g1, %g4, %g4                             
40014fe4:	80 a1 00 03 	cmp  %g4, %g3                                  
40014fe8:	02 80 00 10 	be  40015028 <rtems_rfs_rtems_set_handlers+0x80><== NEVER TAKEN
40014fec:	07 00 00 28 	sethi  %hi(0xa000), %g3                        
    loc->handlers = rtems_rfs_rtems_handlers (device);                
  else if (RTEMS_RFS_S_ISLNK (mode))                                  
40014ff0:	80 a0 80 03 	cmp  %g2, %g3                                  
40014ff4:	02 80 00 22 	be  4001507c <rtems_rfs_rtems_set_handlers+0xd4>
40014ff8:	07 00 00 20 	sethi  %hi(0x8000), %g3                        
    loc->handlers = rtems_rfs_rtems_handlers (link);                  
  else if (RTEMS_RFS_S_ISREG (mode))                                  
40014ffc:	80 a0 80 03 	cmp  %g2, %g3                                  
40015000:	02 80 00 18 	be  40015060 <rtems_rfs_rtems_set_handlers+0xb8><== ALWAYS TAKEN
40015004:	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);            
40015008:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001500c:	93 32 60 10 	srl  %o1, 0x10, %o1                            <== NOT EXECUTED
40015010:	40 00 40 5b 	call  4002517c <printf>                        <== NOT EXECUTED
40015014:	90 12 22 08 	or  %o0, 0x208, %o0                            <== NOT EXECUTED
    return false;                                                     
40015018:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
  }                                                                   
  return true;                                                        
}                                                                     
4001501c:	b0 08 60 01 	and  %g1, 1, %i0                               
40015020:	81 c7 e0 08 	ret                                            
40015024:	81 e8 00 00 	restore                                        
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
40015028:	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);                
4001502c:	05 10 00 e5 	sethi  %hi(0x40039400), %g2                    <== NOT EXECUTED
40015030:	84 10 a0 9c 	or  %g2, 0x9c, %g2	! 4003949c <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
40015034:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        <== NOT EXECUTED
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
}                                                                     
40015038:	b0 08 60 01 	and  %g1, 1, %i0                               <== NOT EXECUTED
4001503c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015040:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
40015044:	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);                   
40015048:	05 10 00 e5 	sethi  %hi(0x40039400), %g2                    
4001504c:	84 10 a0 c8 	or  %g2, 0xc8, %g2	! 400394c8 <rtems_rfs_rtems_dir_handlers>
40015050:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
}                                                                     
40015054:	b0 08 60 01 	and  %g1, 1, %i0                               
40015058:	81 c7 e0 08 	ret                                            
4001505c:	81 e8 00 00 	restore                                        
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
40015060:	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);                  
40015064:	05 10 00 e5 	sethi  %hi(0x40039400), %g2                    
40015068:	84 10 a0 f4 	or  %g2, 0xf4, %g2	! 400394f4 <rtems_rfs_rtems_file_handlers>
4001506c:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
}                                                                     
40015070:	b0 08 60 01 	and  %g1, 1, %i0                               
40015074:	81 c7 e0 08 	ret                                            
40015078:	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);                  
4001507c:	05 10 00 dc 	sethi  %hi(0x40037000), %g2                    
  else                                                                
  {                                                                   
    printf ("rtems-rfs: mode type unknown: %04x\n", mode);            
    return false;                                                     
  }                                                                   
  return true;                                                        
40015080:	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);                  
40015084:	84 10 a1 d4 	or  %g2, 0x1d4, %g2                            
40015088:	10 bf ff e5 	b  4001501c <rtems_rfs_rtems_set_handlers+0x74>
4001508c:	c4 26 20 10 	st  %g2, [ %i0 + 0x10 ]                        
                                                                      

40013fb4 <rtems_rfs_rtems_statvfs>: * @return int */ static int rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc, struct statvfs* sb) {
40013fb4:	9d e3 bf 98 	save  %sp, -104, %sp                           <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
40013fb8:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        <== NOT EXECUTED
  size_t                 blocks;                                      
  size_t                 inodes;                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
40013fbc:	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);  
40013fc0:	fa 00 60 08 	ld  [ %g1 + 8 ], %i5                           <== NOT EXECUTED
  size_t                 blocks;                                      
  size_t                 inodes;                                      
                                                                      
  rtems_rfs_group_usage (fs, &blocks, &inodes);                       
40013fc4:	94 07 bf fc 	add  %fp, -4, %o2                              <== NOT EXECUTED
40013fc8:	7f ff fd 2e 	call  40013480 <rtems_rfs_group_usage>         <== NOT EXECUTED
40013fcc:	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);                 
40013fd0:	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;                  
40013fd4:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           <== NOT EXECUTED
40013fd8:	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);                       
40013fdc:	f0 07 60 08 	ld  [ %i5 + 8 ], %i0                           <== NOT EXECUTED
  sb->f_frsize  = rtems_rfs_fs_media_block_size (fs);                 
40013fe0:	f4 00 60 20 	ld  [ %g1 + 0x20 ], %i2                        <== NOT EXECUTED
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
40013fe4:	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);                            
40013fe8:	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);                           
40013fec:	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);                         
40013ff0:	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;                  
40013ff4:	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;                  
40013ff8:	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);                       
40013ffc:	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;                  
40014000:	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);                           
40014004:	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);                 
40014008:	f4 26 60 04 	st  %i2, [ %i1 + 4 ]                           <== NOT EXECUTED
  sb->f_blocks  = rtems_rfs_fs_media_blocks (fs);                     
4001400c:	c0 26 60 08 	clr  [ %i1 + 8 ]                               <== NOT EXECUTED
40014010:	f6 26 60 0c 	st  %i3, [ %i1 + 0xc ]                         <== NOT EXECUTED
  sb->f_bfree   = rtems_rfs_fs_blocks (fs) - blocks;                  
40014014:	c0 26 60 10 	clr  [ %i1 + 0x10 ]                            <== NOT EXECUTED
40014018:	c6 26 60 14 	st  %g3, [ %i1 + 0x14 ]                        <== NOT EXECUTED
  sb->f_bavail  = sb->f_bfree;                                        
4001401c:	c0 26 60 18 	clr  [ %i1 + 0x18 ]                            <== NOT EXECUTED
40014020:	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;                  
40014024:	c4 26 60 24 	st  %g2, [ %i1 + 0x24 ]                        <== NOT EXECUTED
  sb->f_favail  = sb->f_ffree;                                        
40014028:	c4 26 60 28 	st  %g2, [ %i1 + 0x28 ]                        <== NOT EXECUTED
  sb->f_fsid    = RTEMS_RFS_SB_MAGIC;                                 
4001402c:	03 0a 02 48 	sethi  %hi(0x28092000), %g1                    <== NOT EXECUTED
  sb->f_flag    = rtems_rfs_fs_flags (fs);                            
40014030:	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;                                 
40014034:	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);                         
40014038:	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;                                 
4001403c:	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;                                                           
}                                                                     
40014040:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40014044:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      

400141a4 <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) {
400141a4:	9d e3 bf 98 	save  %sp, -104, %sp                           
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
400141a8:	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),                    
400141ac:	90 10 00 1b 	mov  %i3, %o0                                  
400141b0:	40 00 48 64 	call  40026340 <strlen>                        
400141b4:	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);
400141b8:	f0 06 20 08 	ld  [ %i0 + 8 ], %i0                           
  int                    rc;                                          
                                                                      
  rc = rtems_rfs_symlink (fs, node_name, node_name_len,               
400141bc:	40 00 12 ea 	call  40018d64 <geteuid>                       
400141c0:	ba 10 00 08 	mov  %o0, %i5                                  
400141c4:	40 00 12 e4 	call  40018d54 <getegid>                       
400141c8:	a0 10 00 08 	mov  %o0, %l0                                  
400141cc:	91 2a 20 10 	sll  %o0, 0x10, %o0                            
400141d0:	91 32 20 10 	srl  %o0, 0x10, %o0                            
400141d4:	f0 23 a0 60 	st  %i0, [ %sp + 0x60 ]                        
400141d8:	d0 23 a0 5c 	st  %o0, [ %sp + 0x5c ]                        
400141dc:	98 10 00 1d 	mov  %i5, %o4                                  
400141e0:	9b 2c 20 10 	sll  %l0, 0x10, %o5                            
400141e4:	90 10 00 1c 	mov  %i4, %o0                                  
400141e8:	92 10 00 19 	mov  %i1, %o1                                  
400141ec:	94 10 00 1a 	mov  %i2, %o2                                  
400141f0:	96 10 00 1b 	mov  %i3, %o3                                  
400141f4:	9b 33 60 10 	srl  %o5, 0x10, %o5                            
400141f8:	40 00 34 68 	call  40021398 <rtems_rfs_symlink>             
400141fc:	b0 10 20 00 	clr  %i0                                       
                          target, strlen (target),                    
                          geteuid(), getegid(), parent);              
  if (rc)                                                             
40014200:	80 a2 20 00 	cmp  %o0, 0                                    
40014204:	02 80 00 05 	be  40014218 <rtems_rfs_rtems_symlink+0x74>    <== ALWAYS TAKEN
40014208:	ba 10 00 08 	mov  %o0, %i5                                  
  {                                                                   
    return rtems_rfs_rtems_error ("symlink: linking", rc);            
4001420c:	40 00 3e 4b 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014210:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014214:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40014218:	81 c7 e0 08 	ret                                            
4001421c:	81 e8 00 00 	restore                                        
                                                                      

40014c48 <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 ) {
40014c48:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_rfs_file_system* fs = mt_entry->fs_info;                      
40014c4c:	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);                                     
40014c50:	40 00 24 3e 	call  4001dd48 <rtems_rfs_buffers_release>     
40014c54:	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);            
40014c58:	7f ff e4 f3 	call  4000e024 <rtems_semaphore_release>       
40014c5c:	d0 07 40 00 	ld  [ %i5 ], %o0                               
  if (sc != RTEMS_SUCCESSFUL)                                         
40014c60:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40014c64:	12 80 00 04 	bne  40014c74 <rtems_rfs_rtems_unlock_by_mt_entry+0x2c><== NEVER TAKEN
40014c68:	90 10 20 00 	clr  %o0                                       
40014c6c:	81 c7 e0 08 	ret                                            
40014c70:	81 e8 00 00 	restore                                        
  {                                                                   
#if RTEMS_RFS_TRACE                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))                      
40014c74:	40 00 01 0c 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40014c78:	92 10 20 04 	mov  4, %o1                                    <== NOT EXECUTED
40014c7c:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40014c80:	02 bf ff fb 	be  40014c6c <rtems_rfs_rtems_unlock_by_mt_entry+0x24><== NOT EXECUTED
40014c84:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: mutex: release failed: %s\n",               
40014c88:	40 00 0f 62 	call  40018a10 <rtems_status_text>             <== NOT EXECUTED
40014c8c:	31 10 00 dc 	sethi  %hi(0x40037000), %i0                    <== NOT EXECUTED
40014c90:	b0 16 20 f0 	or  %i0, 0xf0, %i0	! 400370f0 <_CPU_Trap_slot_template+0xc08><== NOT EXECUTED
40014c94:	40 00 41 3a 	call  4002517c <printf>                        <== NOT EXECUTED
40014c98:	93 e8 00 08 	restore  %g0, %o0, %o1                         <== NOT EXECUTED
                                                                      

40014220 <rtems_rfs_rtems_utime>: static int rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc, time_t atime, time_t mtime) {
40014220:	9d e3 bf 78 	save  %sp, -136, %sp                           <== NOT EXECUTED
  rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);  
40014224:	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);                  
40014228:	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);  
4001422c:	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);                  
40014230:	94 07 bf d8 	add  %fp, -40, %o2                             <== NOT EXECUTED
40014234:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40014238:	7f ff fc f4 	call  40013608 <rtems_rfs_inode_open>          <== NOT EXECUTED
4001423c:	96 10 20 01 	mov  1, %o3                                    <== NOT EXECUTED
  if (rc)                                                             
40014240:	b8 92 20 00 	orcc  %o0, 0, %i4                              <== NOT EXECUTED
40014244:	02 80 00 07 	be  40014260 <rtems_rfs_rtems_utime+0x40>      <== NOT EXECUTED
40014248:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("utime: read inode", rc);           
4001424c:	40 00 3e 3b 	call  40023b38 <__errno>                       <== NOT EXECUTED
40014250:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
40014254:	f8 22 00 00 	st  %i4, [ %o0 ]                               <== NOT EXECUTED
40014258:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001425c:	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);                  
40014260:	85 36 60 18 	srl  %i1, 0x18, %g2                            <== NOT EXECUTED
40014264:	87 36 60 10 	srl  %i1, 0x10, %g3                            <== NOT EXECUTED
40014268:	c4 28 60 10 	stb  %g2, [ %g1 + 0x10 ]                       <== NOT EXECUTED
4001426c:	85 36 60 08 	srl  %i1, 8, %g2                               <== NOT EXECUTED
40014270:	c6 28 60 11 	stb  %g3, [ %g1 + 0x11 ]                       <== NOT EXECUTED
40014274:	c4 28 60 12 	stb  %g2, [ %g1 + 0x12 ]                       <== NOT EXECUTED
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40014278:	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);                  
4001427c:	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);                      
40014280:	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);                  
40014284:	c4 28 60 14 	stb  %g2, [ %g1 + 0x14 ]                       <== NOT EXECUTED
40014288:	87 36 a0 10 	srl  %i2, 0x10, %g3                            <== NOT EXECUTED
4001428c:	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);                            
40014290:	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);                  
40014294:	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);                  
40014298:	c6 28 60 15 	stb  %g3, [ %g1 + 0x15 ]                       <== NOT EXECUTED
4001429c:	c4 28 60 16 	stb  %g2, [ %g1 + 0x16 ]                       <== NOT EXECUTED
400142a0:	f4 28 60 17 	stb  %i2, [ %g1 + 0x17 ]                       <== NOT EXECUTED
400142a4:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
400142a8:	7f ff fd 50 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
400142ac:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
  if (rc)                                                             
400142b0:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400142b4:	02 bf ff e9 	be  40014258 <rtems_rfs_rtems_utime+0x38>      <== NOT EXECUTED
400142b8:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
  {                                                                   
    return rtems_rfs_rtems_error ("utime: closing inode", rc);        
400142bc:	40 00 3e 1f 	call  40023b38 <__errno>                       <== NOT EXECUTED
400142c0:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
400142c4:	fa 22 00 00 	st  %i5, [ %o0 ]                               <== NOT EXECUTED
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
400142c8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400142cc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40011e4c <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) {
40011e4c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
40011e50:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  if (dividend == 0)                                                  
40011e54:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40011e58:	02 80 00 06 	be  40011e70 <rtems_rfs_rup_quotient+0x24>     <== NOT EXECUTED
40011e5c:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
    return 1;                                                         
  return ((dividend - 1) / divisor) + 1;                              
40011e60:	90 02 3f ff 	add  %o0, -1, %o0                              <== NOT EXECUTED
40011e64:	7f ff c2 0f 	call  400026a0 <.udiv>                         <== NOT EXECUTED
40011e68:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40011e6c:	b0 02 20 01 	add  %o0, 1, %i0                               <== NOT EXECUTED
}                                                                     
40011e70:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40011e74:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001d518 <rtems_rfs_scan_chain>: */ static rtems_rfs_buffer* rtems_rfs_scan_chain (rtems_chain_control* chain, uint32_t* count, rtems_rfs_buffer_block block) {
4001d518:	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))                
4001d51c:	90 10 20 00 	clr  %o0                                       
4001d520:	92 10 20 80 	mov  0x80, %o1                                 
4001d524:	7f ff de e0 	call  400150a4 <rtems_rfs_trace>               
4001d528:	fa 06 20 08 	ld  [ %i0 + 8 ], %i5                           
4001d52c:	80 8a 20 ff 	btst  0xff, %o0                                
4001d530:	32 80 00 37 	bne,a   4001d60c <rtems_rfs_scan_chain+0xf4>   <== NEVER TAKEN
4001d534:	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));            
4001d538:	39 10 00 df 	sethi  %hi(0x40037c00), %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))                          
4001d53c:	80 a7 40 18 	cmp  %i5, %i0                                  
4001d540:	12 80 00 0b 	bne  4001d56c <rtems_rfs_scan_chain+0x54>      <== ALWAYS TAKEN
4001d544:	b8 17 23 58 	or  %i4, 0x358, %i4                            
      return buffer;                                                  
    }                                                                 
    node = rtems_chain_previous (node);                               
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
4001d548:	10 80 00 2a 	b  4001d5f0 <rtems_rfs_scan_chain+0xd8>        <== NOT EXECUTED
4001d54c:	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)
4001d550:	80 a0 40 1a 	cmp  %g1, %i2                                  
4001d554:	02 80 00 14 	be  4001d5a4 <rtems_rfs_scan_chain+0x8c>       
4001d558:	90 10 20 00 	clr  %o0                                       
 */                                                                   
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(                     
  Chain_Node *the_node                                                
)                                                                     
{                                                                     
  return the_node->previous;                                          
4001d55c:	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))                          
4001d560:	80 a7 40 18 	cmp  %i5, %i0                                  
4001d564:	02 80 00 23 	be  4001d5f0 <rtems_rfs_scan_chain+0xd8>       
4001d568:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    buffer = (rtems_rfs_buffer*) node;                                
                                                                      
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))              
4001d56c:	90 10 20 00 	clr  %o0                                       
4001d570:	7f ff de cd 	call  400150a4 <rtems_rfs_trace>               
4001d574:	92 10 20 80 	mov  0x80, %o1                                 
4001d578:	80 8a 20 ff 	btst  0xff, %o0                                
4001d57c:	22 bf ff f5 	be,a   4001d550 <rtems_rfs_scan_chain+0x38>    <== ALWAYS TAKEN
4001d580:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
      printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));            
4001d584:	d2 07 60 34 	ld  [ %i5 + 0x34 ], %o1                        <== NOT EXECUTED
4001d588:	40 00 1e fd 	call  4002517c <printf>                        <== NOT EXECUTED
4001d58c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
                                                                      
    if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
4001d590:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        <== NOT EXECUTED
4001d594:	80 a0 40 1a 	cmp  %g1, %i2                                  <== NOT EXECUTED
4001d598:	32 bf ff f2 	bne,a   4001d560 <rtems_rfs_scan_chain+0x48>   <== NOT EXECUTED
4001d59c:	fa 07 60 04 	ld  [ %i5 + 4 ], %i5                           <== NOT EXECUTED
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))            
4001d5a0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
4001d5a4:	7f ff de c0 	call  400150a4 <rtems_rfs_trace>               
4001d5a8:	92 10 20 80 	mov  0x80, %o1                                 
4001d5ac:	80 8a 20 ff 	btst  0xff, %o0                                
4001d5b0:	22 80 00 07 	be,a   4001d5cc <rtems_rfs_scan_chain+0xb4>    <== ALWAYS TAKEN
4001d5b4:	c2 06 40 00 	ld  [ %i1 ], %g1                               
        printf (": found block=%" PRIuPTR "\n",                       
4001d5b8:	d2 07 60 34 	ld  [ %i5 + 0x34 ], %o1                        <== NOT EXECUTED
4001d5bc:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001d5c0:	40 00 1e ef 	call  4002517c <printf>                        <== NOT EXECUTED
4001d5c4:	90 12 23 60 	or  %o0, 0x360, %o0	! 40037f60 <CSWTCH.2+0x170><== NOT EXECUTED
                ((intptr_t)(buffer->user)));                          
                                                                      
      (*count)--;                                                     
4001d5c8:	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 );                                         
4001d5cc:	90 10 00 1d 	mov  %i5, %o0                                  
4001d5d0:	82 00 7f ff 	add  %g1, -1, %g1                              
      rtems_chain_extract (node);                                     
      rtems_chain_set_off_chain (node);                               
      return buffer;                                                  
4001d5d4:	b0 10 00 1d 	mov  %i5, %i0                                  
4001d5d8:	7f ff f3 a1 	call  4001a45c <_Chain_Extract>                
4001d5dc:	c2 26 40 00 	st  %g1, [ %i1 ]                               
 */                                                                   
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(                       
  Chain_Node *node                                                    
)                                                                     
{                                                                     
  node->next = node->previous = NULL;                                 
4001d5e0:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
4001d5e4:	c0 27 40 00 	clr  [ %i5 ]                                   
4001d5e8:	81 c7 e0 08 	ret                                            
4001d5ec:	81 e8 00 00 	restore                                        
    }                                                                 
    node = rtems_chain_previous (node);                               
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
4001d5f0:	7f ff de ad 	call  400150a4 <rtems_rfs_trace>               
4001d5f4:	92 10 20 80 	mov  0x80, %o1                                 
4001d5f8:	80 8a 20 ff 	btst  0xff, %o0                                
4001d5fc:	12 80 00 0a 	bne  4001d624 <rtems_rfs_scan_chain+0x10c>     <== NEVER TAKEN
4001d600:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    
    printf (": not found\n");                                         
                                                                      
  return NULL;                                                        
}                                                                     
4001d604:	81 c7 e0 08 	ret                                            
4001d608:	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);
4001d60c:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
4001d610:	11 10 00 df 	sethi  %hi(0x40037c00), %o0                    <== NOT EXECUTED
4001d614:	40 00 1e da 	call  4002517c <printf>                        <== NOT EXECUTED
4001d618:	90 12 23 28 	or  %o0, 0x328, %o0	! 40037f28 <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));            
4001d61c:	10 bf ff c8 	b  4001d53c <rtems_rfs_scan_chain+0x24>        <== NOT EXECUTED
4001d620:	39 10 00 df 	sethi  %hi(0x40037c00), %i4                    <== NOT EXECUTED
  }                                                                   
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))                
    printf (": not found\n");                                         
                                                                      
  return NULL;                                                        
4001d624:	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");                                         
4001d628:	40 00 1f 6d 	call  400253dc <puts>                          <== NOT EXECUTED
4001d62c:	90 12 23 78 	or  %o0, 0x378, %o0                            <== NOT EXECUTED
                                                                      
  return NULL;                                                        
}                                                                     
4001d630:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001d634:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

4001bc08 <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,
4001bc08:	9d e3 bf 90 	save  %sp, -112, %sp                           
  *found = false;                                                     
                                                                      
  /*                                                                  
   * Load the bitmap.                                                 
   */                                                                 
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
4001bc0c:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001bc10:	ac 10 00 18 	mov  %i0, %l6                                  
  rtems_rfs_bitmap_element* map_bits;                                 
  int                       map_index;                                
  int                       map_offset;                               
  int                       rc;                                       
                                                                      
  *found = false;                                                     
4001bc14:	c0 2e 80 00 	clrb  [ %i2 ]                                  
                                                                      
  /*                                                                  
   * Load the bitmap.                                                 
   */                                                                 
  rc = rtems_rfs_bitmap_load_map (control, &map);                     
4001bc18:	7f ff ff e7 	call  4001bbb4 <rtems_rfs_bitmap_load_map>     
4001bc1c:	92 07 bf fc 	add  %fp, -4, %o1                              
  if (rc > 0)                                                         
4001bc20:	b0 92 20 00 	orcc  %o0, 0, %i0                              
4001bc24:	24 80 00 04 	ble,a   4001bc34 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2c><== ALWAYS TAKEN
4001bc28:	f8 06 40 00 	ld  [ %i1 ], %i4                               
  }                                                                   
  while (((direction < 0) && (test_bit >= end_bit))                   
         || ((direction > 0) && (test_bit <= end_bit)));              
                                                                      
  return 0;                                                           
}                                                                     
4001bc2c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001bc30:	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);                         
4001bc34:	a1 2e e0 0b 	sll  %i3, 0xb, %l0                             
                                                                      
  if (end_bit < 0)                                                    
4001bc38:	a0 84 00 1c 	addcc  %l0, %i4, %l0                           
4001bc3c:	2c 80 00 06 	bneg,a   4001bc54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
4001bc40:	a0 10 20 00 	clr  %l0                                       
    end_bit = 0;                                                      
  else if (end_bit >= control->size)                                  
4001bc44:	c2 05 a0 0c 	ld  [ %l6 + 0xc ], %g1                         
4001bc48:	80 a4 00 01 	cmp  %l0, %g1                                  
4001bc4c:	3a 80 00 02 	bcc,a   4001bc54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c>
4001bc50:	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];                  
4001bc54:	ee 05 a0 14 	ld  [ %l6 + 0x14 ], %l7                        
  map_bits    = &map[map_index];                                      
4001bc58:	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);              
4001bc5c:	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];                                      
4001bc60:	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);             
4001bc64:	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))                
4001bc68:	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];                  
4001bc6c:	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)))            
4001bc70:	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];                                      
4001bc74:	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)))            
4001bc78:	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))                
4001bc7c:	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);             
4001bc80:	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);            
4001bc84:	92 0c a0 1f 	and  %l2, 0x1f, %o1                            
                                                                      
  search_bits = &control->search_bits[search_index];                  
4001bc88:	ae 05 c0 02 	add  %l7, %g2, %l7                             
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
4001bc8c:	b1 2e e0 02 	sll  %i3, 2, %i0                               
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001bc90:	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);                     
4001bc94:	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))                
4001bc98:	c2 27 bf f4 	st  %g1, [ %fp + -12 ]                         
            || ((direction > 0) && (test_bit >= end_bit)))            
4001bc9c:	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))
4001bca0:	c8 05 c0 00 	ld  [ %l7 ], %g4                               
4001bca4:	80 a1 20 00 	cmp  %g4, 0                                    
4001bca8:	02 80 00 49 	be  4001bdcc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1c4>
4001bcac:	80 a6 e0 00 	cmp  %i3, 0                                    
                                                                      
  return 0;                                                           
}                                                                     
                                                                      
static int                                                            
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
4001bcb0:	86 06 c0 12 	add  %i3, %l2, %g3                             
4001bcb4:	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)                                     
4001bcb8:	80 a2 60 1f 	cmp  %o1, 0x1f                                 
4001bcbc:	18 80 00 52 	bgu  4001be04 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1fc>
4001bcc0:	9f 2c 40 09 	sll  %l1, %o1, %o7                             
             && (search_offset < rtems_rfs_bitmap_element_bits ()))   
      {                                                               
        if (!rtems_rfs_bitmap_test (*search_bits, search_offset))     
4001bcc4:	80 8b c0 04 	btst  %o7, %g4                                 
4001bcc8:	22 80 00 13 	be,a   4001bd14 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x10c>
4001bccc:	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))       
4001bcd0:	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);                     
4001bcd4:	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))       
4001bcd8:	80 88 40 02 	btst  %g1, %g2                                 
4001bcdc:	02 80 00 0b 	be  4001bd08 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x100>
4001bce0:	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);                    
4001bce4:	10 80 00 55 	b  4001be38 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x230>
4001bce8:	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)                                    
4001bcec:	80 a7 60 1f 	cmp  %i5, 0x1f                                 
4001bcf0:	18 80 00 08 	bgu  4001bd10 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108><== NEVER TAKEN
4001bcf4:	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);                     
4001bcf8:	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))       
4001bcfc:	80 88 80 01 	btst  %g2, %g1                                 
4001bd00:	12 80 00 4d 	bne  4001be34 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x22c>
4001bd04:	80 a4 00 1c 	cmp  %l0, %i4                                  
              *found = true;                                          
              rtems_rfs_buffer_mark_dirty (control->buffer);          
              return 0;                                               
            }                                                         
                                                                      
            if (test_bit == end_bit)                                  
4001bd08:	32 bf ff f9 	bne,a   4001bcec <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe4>
4001bd0c:	ba 07 40 1b 	add  %i5, %i3, %i5                             
            map_offset += direction;                                  
            test_bit   += direction;                                  
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
4001bd10:	a6 04 c0 18 	add  %l3, %i0, %l3                             
        map_index += direction;                                       
        map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001bd14:	80 a6 e0 00 	cmp  %i3, 0                                    
4001bd18:	04 80 00 44 	ble  4001be28 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x220>
4001bd1c:	a4 04 80 1b 	add  %l2, %i3, %l2                             
4001bd20:	b8 10 20 00 	clr  %i4                                       
4001bd24:	ba 10 20 00 	clr  %i5                                       
                                                                      
        test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
4001bd28:	b8 00 c0 1c 	add  %g3, %i4, %i4                             
                                                                      
        search_offset += direction;                                   
4001bd2c:	92 02 40 1b 	add  %o1, %i3, %o1                             
                                                                      
        if (((direction < 0) && (test_bit <= end_bit))                
4001bd30:	84 10 00 15 	mov  %l5, %g2                                  
4001bd34:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001bd38:	16 80 00 03 	bge  4001bd44 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x13c>
4001bd3c:	82 10 20 01 	mov  1, %g1                                    
4001bd40:	82 10 20 00 	clr  %g1                                       
4001bd44:	80 88 60 ff 	btst  0xff, %g1                                
4001bd48:	32 80 00 5b 	bne,a   4001beb4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2ac>
4001bd4c:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
4001bd50:	86 00 c0 0b 	add  %g3, %o3, %g3                             
            || ((direction > 0) && (test_bit >= end_bit)))            
4001bd54:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001bd58:	04 80 00 03 	ble  4001bd64 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x15c>
4001bd5c:	82 10 20 01 	mov  1, %g1                                    
4001bd60:	82 10 20 00 	clr  %g1                                       
4001bd64:	80 88 60 ff 	btst  0xff, %g1                                
4001bd68:	02 bf ff d5 	be  4001bcbc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
4001bd6c:	80 a2 60 1f 	cmp  %o1, 0x1f                                 
4001bd70:	80 a5 20 00 	cmp  %l4, 0                                    
4001bd74:	02 bf ff d2 	be  4001bcbc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb4>
4001bd78:	80 a2 60 1f 	cmp  %o1, 0x1f                                 
      }                                                               
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
4001bd7c:	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)))            
4001bd80:	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;
4001bd84:	92 10 20 00 	clr  %o1                                       
  }                                                                   
  while (((direction < 0) && (test_bit >= end_bit))                   
         || ((direction > 0) && (test_bit <= end_bit)));              
4001bd88:	80 88 60 ff 	btst  0xff, %g1                                
4001bd8c:	02 80 00 06 	be  4001bda4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x19c>
4001bd90:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001bd94:	80 88 a0 ff 	btst  0xff, %g2                                
4001bd98:	32 bf ff c3 	bne,a   4001bca4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
4001bd9c:	c8 05 c0 00 	ld  [ %l7 ], %g4                               
4001bda0:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001bda4:	16 80 00 03 	bge  4001bdb0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a8>
4001bda8:	82 10 20 01 	mov  1, %g1                                    
4001bdac:	82 10 20 00 	clr  %g1                                       
4001bdb0:	80 88 60 ff 	btst  0xff, %g1                                
4001bdb4:	02 80 00 04 	be  4001bdc4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1bc>
4001bdb8:	80 a5 20 00 	cmp  %l4, 0                                    
4001bdbc:	32 bf ff ba 	bne,a   4001bca4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x9c>
4001bdc0:	c8 05 c0 00 	ld  [ %l7 ], %g4                               
                                                                      
  return 0;                                                           
4001bdc4:	81 c7 e0 08 	ret                                            
4001bdc8:	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)                                              
4001bdcc:	04 80 00 34 	ble  4001be9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x294>
4001bdd0:	b8 0f 3f e0 	and  %i4, -32, %i4                             
      {                                                               
        bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
4001bdd4:	82 10 20 20 	mov  0x20, %g1                                 
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
        map_offset = 0;                                               
4001bdd8:	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;
4001bddc:	92 20 40 09 	sub  %g1, %o1, %o1                             
        test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();  
4001bde0:	83 2a 60 05 	sll  %o1, 5, %g1                               
4001bde4:	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;                           
4001bde8:	d6 27 bf f0 	st  %o3, [ %fp + -16 ]                         
4001bdec:	7f ff 99 f3 	call  400025b8 <.umul>                         
4001bdf0:	90 10 00 1b 	mov  %i3, %o0                                  
4001bdf4:	d6 07 bf f0 	ld  [ %fp + -16 ], %o3                         
4001bdf8:	83 2a 20 02 	sll  %o0, 2, %g1                               
      map_index += direction * bits_skipped;                          
4001bdfc:	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;                           
4001be00:	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;
4001be04:	80 a6 e0 00 	cmp  %i3, 0                                    
4001be08:	04 80 00 1c 	ble  4001be78 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x270>
4001be0c:	ae 05 c0 18 	add  %l7, %i0, %l7                             
4001be10:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001be14:	04 80 00 03 	ble  4001be20 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218>
4001be18:	82 10 20 01 	mov  1, %g1                                    
4001be1c:	82 10 20 00 	clr  %g1                                       
4001be20:	10 bf ff d9 	b  4001bd84 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x17c>
4001be24:	84 10 20 00 	clr  %g2                                       
          }                                                           
        }                                                             
                                                                      
        map_bits  += direction;                                       
        map_index += direction;                                       
        map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4001be28:	b8 10 20 1f 	mov  0x1f, %i4                                 
4001be2c:	10 bf ff bf 	b  4001bd28 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x120>
4001be30:	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);                    
4001be34:	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,                   
4001be38:	80 a0 60 00 	cmp  %g1, 0                                    
4001be3c:	12 80 00 05 	bne  4001be50 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x248>
4001be40:	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);                    
4001be44:	c2 05 c0 00 	ld  [ %l7 ], %g1                               
4001be48:	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,    
4001be4c:	de 25 c0 00 	st  %o7, [ %l7 ]                               
                                                     1 << search_offset);
              control->free--;                                        
4001be50:	c2 05 a0 10 	ld  [ %l6 + 0x10 ], %g1                        
              *bit = test_bit;                                        
              *found = true;                                          
              rtems_rfs_buffer_mark_dirty (control->buffer);          
4001be54:	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--;                                        
4001be58:	82 00 7f ff 	add  %g1, -1, %g1                              
4001be5c:	c2 25 a0 10 	st  %g1, [ %l6 + 0x10 ]                        
              *bit = test_bit;                                        
4001be60:	f8 26 40 00 	st  %i4, [ %i1 ]                               
              *found = true;                                          
4001be64:	82 10 20 01 	mov  1, %g1                                    
4001be68:	c2 2e 80 00 	stb  %g1, [ %i2 ]                              
              rtems_rfs_buffer_mark_dirty (control->buffer);          
4001be6c:	c2 28 80 00 	stb  %g1, [ %g2 ]                              
              return 0;                                               
4001be70:	81 c7 e0 08 	ret                                            
4001be74:	91 e8 20 00 	restore  %g0, 0, %o0                           
4001be78:	84 10 00 15 	mov  %l5, %g2                                  
4001be7c:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001be80:	14 80 00 04 	bg  4001be90 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x288>
4001be84:	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;
4001be88:	10 bf ff c0 	b  4001bd88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001be8c:	92 10 20 1f 	mov  0x1f, %o1                                 
4001be90:	82 10 20 00 	clr  %g1                                       
4001be94:	10 bf ff bd 	b  4001bd88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001be98:	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;
4001be9c:	83 2a 60 05 	sll  %o1, 5, %g1                               
        map_offset = rtems_rfs_bitmap_element_bits () - 1;            
4001bea0:	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;
4001bea4:	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;                             
4001bea8:	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;
4001beac:	10 bf ff cf 	b  4001bde8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e0>
4001beb0:	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))                
4001beb4:	80 a0 60 00 	cmp  %g1, 0                                    
4001beb8:	22 bf ff a7 	be,a   4001bd54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x14c>
4001bebc:	86 00 c0 0b 	add  %g3, %o3, %g3                             
      }                                                               
      map_bits += direction * bits_skipped;                           
      map_index += direction * bits_skipped;                          
    }                                                                 
                                                                      
    search_bits  += direction;                                        
4001bec0:	ae 05 c0 18 	add  %l7, %i0, %l7                             
4001bec4:	80 a4 00 1c 	cmp  %l0, %i4                                  
4001bec8:	04 80 00 03 	ble  4001bed4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x2cc><== NEVER TAKEN
4001becc:	82 10 20 01 	mov  1, %g1                                    
4001bed0:	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))                
4001bed4:	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;
4001bed8:	10 bf ff ac 	b  4001bd88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x180>
4001bedc:	92 10 20 1f 	mov  0x1f, %o1                                 
                                                                      

40021398 <rtems_rfs_symlink>: const char* link, int link_length, uid_t uid, gid_t gid, rtems_rfs_ino parent) {
40021398:	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))                      
4002139c:	90 10 20 02 	mov  2, %o0                                    
                   const char*            link,                       
                   int                    link_length,                
                   uid_t                  uid,                        
                   gid_t                  gid,                        
                   rtems_rfs_ino          parent)                     
{                                                                     
400213a0:	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))                      
400213a4:	7f ff cf 40 	call  400150a4 <rtems_rfs_trace>               
400213a8:	92 10 20 00 	clr  %o1                                       
400213ac:	80 8a 20 ff 	btst  0xff, %o0                                
400213b0:	32 80 00 08 	bne,a   400213d0 <rtems_rfs_symlink+0x38>      <== NEVER TAKEN
400213b4:	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))                    
400213b8:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           
400213bc:	80 a7 00 01 	cmp  %i4, %g1                                  
400213c0:	0a 80 00 22 	bcs  40021448 <rtems_rfs_symlink+0xb0>         <== ALWAYS TAKEN
400213c4:	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;                                                          
}                                                                     
400213c8:	81 c7 e0 08 	ret                                            
400213cc:	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);  
400213d0:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
400213d4:	40 00 0f 6a 	call  4002517c <printf>                        <== NOT EXECUTED
400213d8:	90 12 23 f8 	or  %o0, 0x3f8, %o0	! 400393f8 <CSWTCH.2+0x1608><== NOT EXECUTED
400213dc:	a0 10 00 19 	mov  %i1, %l0                                  <== NOT EXECUTED
    for (c = 0; c < length; c++)                                      
400213e0:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
400213e4:	04 80 00 08 	ble  40021404 <rtems_rfs_symlink+0x6c>         <== NOT EXECUTED
400213e8:	a2 06 40 1a 	add  %i1, %i2, %l1                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
400213ec:	d0 4c 00 00 	ldsb  [ %l0 ], %o0                             <== NOT EXECUTED
400213f0:	40 00 0f cd 	call  40025324 <putchar>                       <== NOT EXECUTED
400213f4:	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++)                                      
400213f8:	80 a4 00 11 	cmp  %l0, %l1                                  <== NOT EXECUTED
400213fc:	32 bf ff fd 	bne,a   400213f0 <rtems_rfs_symlink+0x58>      <== NOT EXECUTED
40021400:	d0 4c 00 00 	ldsb  [ %l0 ], %o0                             <== NOT EXECUTED
      printf ("%c", name[c]);                                         
    printf (" link:");                                                
40021404:	11 10 00 e5 	sethi  %hi(0x40039400), %o0                    <== NOT EXECUTED
40021408:	40 00 0f 5d 	call  4002517c <printf>                        <== NOT EXECUTED
4002140c:	90 12 20 20 	or  %o0, 0x20, %o0	! 40039420 <CSWTCH.2+0x1630><== NOT EXECUTED
40021410:	b4 10 00 1b 	mov  %i3, %i2                                  <== NOT EXECUTED
    for (c = 0; c < link_length; c++)                                 
40021414:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40021418:	04 bf ff e8 	ble  400213b8 <rtems_rfs_symlink+0x20>         <== NOT EXECUTED
4002141c:	a0 07 00 1b 	add  %i4, %i3, %l0                             <== NOT EXECUTED
      printf ("%c", link[c]);                                         
40021420:	d0 4e 80 00 	ldsb  [ %i2 ], %o0                             <== NOT EXECUTED
40021424:	40 00 0f c0 	call  40025324 <putchar>                       <== NOT EXECUTED
40021428:	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++)                                 
4002142c:	80 a6 80 10 	cmp  %i2, %l0                                  <== NOT EXECUTED
40021430:	32 bf ff fd 	bne,a   40021424 <rtems_rfs_symlink+0x8c>      <== NOT EXECUTED
40021434:	d0 4e 80 00 	ldsb  [ %i2 ], %o0                             <== NOT EXECUTED
      printf ("%c", link[c]);                                         
  }                                                                   
                                                                      
  if (link_length >= rtems_rfs_fs_block_size (fs))                    
40021438:	c2 06 20 08 	ld  [ %i0 + 8 ], %g1                           <== NOT EXECUTED
4002143c:	80 a7 00 01 	cmp  %i4, %g1                                  <== NOT EXECUTED
40021440:	1a bf ff e2 	bcc  400213c8 <rtems_rfs_symlink+0x30>         <== NOT EXECUTED
40021444:	b4 10 20 5b 	mov  0x5b, %i2                                 <== NOT EXECUTED
    return ENAMETOOLONG;                                              
                                                                      
  rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),       
40021448:	40 00 13 be 	call  40026340 <strlen>                        
4002144c:	90 10 00 19 	mov  %i1, %o0                                  
40021450:	d2 07 a0 60 	ld  [ %fp + 0x60 ], %o1                        
40021454:	82 07 bf 74 	add  %fp, -140, %g1                            
40021458:	96 10 00 08 	mov  %o0, %o3                                  
4002145c:	fa 23 a0 5c 	st  %i5, [ %sp + 0x5c ]                        
40021460:	e4 23 a0 60 	st  %l2, [ %sp + 0x60 ]                        
40021464:	90 10 00 18 	mov  %i0, %o0                                  
40021468:	c2 23 a0 64 	st  %g1, [ %sp + 0x64 ]                        
4002146c:	94 10 00 19 	mov  %i1, %o2                                  
40021470:	9a 10 20 01 	mov  1, %o5                                    
40021474:	19 00 00 28 	sethi  %hi(0xa000), %o4                        
40021478:	7f ff c9 b6 	call  40013b50 <rtems_rfs_inode_create>        
4002147c:	98 13 21 ff 	or  %o4, 0x1ff, %o4	! a1ff <PROM_START+0xa1ff> 
                               RTEMS_RFS_S_SYMLINK,                   
                               1, uid, gid, &ino);                    
  if (rc > 0)                                                         
40021480:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40021484:	14 bf ff d1 	bg  400213c8 <rtems_rfs_symlink+0x30>          <== NEVER TAKEN
40021488:	d2 07 bf 74 	ld  [ %fp + -140 ], %o1                        
    return rc;                                                        
                                                                      
  rc = rtems_rfs_inode_open (fs, ino, &inode, true);                  
4002148c:	90 10 00 18 	mov  %i0, %o0                                  
40021490:	94 07 bf 88 	add  %fp, -120, %o2                            
40021494:	7f ff c8 5d 	call  40013608 <rtems_rfs_inode_open>          
40021498:	96 10 20 01 	mov  1, %o3                                    
  if (rc > 0)                                                         
4002149c:	b4 92 20 00 	orcc  %o0, 0, %i2                              
400214a0:	14 bf ff ca 	bg  400213c8 <rtems_rfs_symlink+0x30>          <== NEVER TAKEN
400214a4:	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)                   
400214a8:	38 80 00 20 	bgu,a   40021528 <rtems_rfs_symlink+0x190>     <== NEVER TAKEN
400214ac:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  {                                                                   
    memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
400214b0:	d0 07 bf 94 	ld  [ %fp + -108 ], %o0                        
400214b4:	92 10 20 00 	clr  %o1                                       
400214b8:	94 10 20 14 	mov  0x14, %o2                                 
400214bc:	40 00 0e b2 	call  40024f84 <memset>                        
400214c0:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
    memcpy (inode.node->data.name, link, link_length);                
400214c4:	d0 07 bf 94 	ld  [ %fp + -108 ], %o0                        
400214c8:	92 10 00 1b 	mov  %i3, %o1                                  
400214cc:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
400214d0:	40 00 0e 1e 	call  40024d48 <memcpy>                        
400214d4:	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);      
400214d8:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400214dc:	c0 28 60 0c 	clrb  [ %g1 + 0xc ]                            
400214e0:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400214e4:	c0 28 60 0d 	clrb  [ %g1 + 0xd ]                            
400214e8:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400214ec:	c0 28 60 0e 	clrb  [ %g1 + 0xe ]                            
400214f0:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400214f4:	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);    
400214f8:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
400214fc:	85 37 20 08 	srl  %i4, 8, %g2                               
40021500:	c4 28 60 0a 	stb  %g2, [ %g1 + 0xa ]                        
40021504:	c2 07 bf 94 	ld  [ %fp + -108 ], %g1                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_rfs_inode_set_block_offset (&inode, link_length);             
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
40021508:	90 10 00 18 	mov  %i0, %o0                                  
4002150c:	f8 28 60 0b 	stb  %i4, [ %g1 + 0xb ]                        
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40021510:	82 10 20 01 	mov  1, %g1                                    
40021514:	92 07 bf 88 	add  %fp, -120, %o1                            
40021518:	7f ff c8 b4 	call  400137e8 <rtems_rfs_inode_close>         
4002151c:	c2 2f bf 98 	stb  %g1, [ %fp + -104 ]                       
40021520:	10 bf ff aa 	b  400213c8 <rtems_rfs_symlink+0x30>           
40021524:	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);                 
40021528:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
4002152c:	7f ff ec b9 	call  4001c810 <rtems_rfs_block_map_open>      <== NOT EXECUTED
40021530:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
40021534:	b4 10 00 08 	mov  %o0, %i2                                  <== NOT EXECUTED
    if (rc > 0)                                                       
40021538:	80 a6 a0 00 	cmp  %i2, 0                                    <== NOT EXECUTED
4002153c:	04 80 00 05 	ble  40021550 <rtems_rfs_symlink+0x1b8>        <== NOT EXECUTED
40021540:	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);                             
40021544:	7f ff c8 a9 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40021548:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
4002154c:	30 bf ff 9f 	b,a   400213c8 <rtems_rfs_symlink+0x30>        <== NOT EXECUTED
    {                                                                 
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
                                                                      
    rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);              
40021550:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
40021554:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
40021558:	7f ff ee 07 	call  4001cd74 <rtems_rfs_block_map_grow>      <== NOT EXECUTED
4002155c:	96 07 bf 78 	add  %fp, -136, %o3                            <== NOT EXECUTED
    if (rc > 0)                                                       
40021560:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
40021564:	04 80 00 07 	ble  40021580 <rtems_rfs_symlink+0x1e8>        <== NOT EXECUTED
40021568:	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);                           
4002156c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40021570:	7f ff ed 09 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
40021574:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &inode);                             
40021578:	10 bf ff f3 	b  40021544 <rtems_rfs_symlink+0x1ac>          <== NOT EXECUTED
4002157c:	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;                                              
40021580:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40021584:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
40021588:	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); 
4002158c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40021590:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
40021594:	7f ff f0 a3 	call  4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40021598:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
    if (rc > 0)                                                       
4002159c:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
400215a0:	14 bf ff f4 	bg  40021570 <rtems_rfs_symlink+0x1d8>         <== NOT EXECUTED
400215a4:	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);                           
400215a8:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        <== NOT EXECUTED
                                                                      
    memset (data, 0xff, rtems_rfs_fs_block_size (fs));                
400215ac:	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);                           
400215b0:	fa 00 60 1c 	ld  [ %g1 + 0x1c ], %i5                        <== NOT EXECUTED
                                                                      
    memset (data, 0xff, rtems_rfs_fs_block_size (fs));                
400215b4:	92 10 20 ff 	mov  0xff, %o1                                 <== NOT EXECUTED
400215b8:	40 00 0e 73 	call  40024f84 <memset>                        <== NOT EXECUTED
400215bc:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
    memcpy (data, link, link_length);                                 
400215c0:	94 10 00 1c 	mov  %i4, %o2                                  <== NOT EXECUTED
400215c4:	92 10 00 1b 	mov  %i3, %o1                                  <== NOT EXECUTED
400215c8:	40 00 0d e0 	call  40024d48 <memcpy>                        <== NOT EXECUTED
400215cc:	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);                       
400215d0:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
400215d4:	7f ff f0 19 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400215d8:	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);                        
400215dc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400215e0:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400215e4:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
400215e8:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== NOT EXECUTED
400215ec:	7f ff ec ea 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
400215f0:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
    if (rc > 0)                                                       
400215f4:	b4 92 20 00 	orcc  %o0, 0, %i2                              <== NOT EXECUTED
400215f8:	04 bf ff c0 	ble  400214f8 <rtems_rfs_symlink+0x160>        <== NOT EXECUTED
400215fc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40021600:	30 bf ff d1 	b,a   40021544 <rtems_rfs_symlink+0x1ac>       <== NOT EXECUTED
                                                                      

40021604 <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) {
40021604:	9d e3 bf 18 	save  %sp, -232, %sp                           
  rtems_rfs_inode_handle inode;                                       
  int                    rc;                                          
                                                                      
  if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))                 
40021608:	90 10 20 04 	mov  4, %o0                                    
4002160c:	7f ff ce a6 	call  400150a4 <rtems_rfs_trace>               
40021610:	92 10 20 00 	clr  %o1                                       
40021614:	80 8a 20 ff 	btst  0xff, %o0                                
40021618:	12 80 00 17 	bne  40021674 <rtems_rfs_symlink_read+0x70>    <== NEVER TAKEN
4002161c:	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);                 
40021620:	90 10 00 18 	mov  %i0, %o0                                  
40021624:	92 10 00 19 	mov  %i1, %o1                                  
40021628:	94 07 bf 88 	add  %fp, -120, %o2                            
4002162c:	7f ff c7 f7 	call  40013608 <rtems_rfs_inode_open>          
40021630:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40021634:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021638:	12 80 00 0d 	bne  4002166c <rtems_rfs_symlink_read+0x68>    <== NEVER TAKEN
4002163c:	d2 07 bf 94 	ld  [ %fp + -108 ], %o1                        
    return rc;                                                        
                                                                      
  if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))         
40021640:	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);                    
40021644:	c4 0a 60 02 	ldub  [ %o1 + 2 ], %g2                         
40021648:	85 28 a0 08 	sll  %g2, 8, %g2                               
4002164c:	84 08 80 01 	and  %g2, %g1, %g2                             
40021650:	03 00 00 28 	sethi  %hi(0xa000), %g1                        
40021654:	80 a0 80 01 	cmp  %g2, %g1                                  
40021658:	02 80 00 0c 	be  40021688 <rtems_rfs_symlink_read+0x84>     <== ALWAYS TAKEN
4002165c:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
40021660:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
40021664:	7f ff c8 61 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40021668:	ba 10 20 16 	mov  0x16, %i5                                 <== NOT EXECUTED
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
                                                                      
  return rc;                                                          
}                                                                     
4002166c:	81 c7 e0 08 	ret                                            
40021670:	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);     
40021674:	11 10 00 e5 	sethi  %hi(0x40039400), %o0                    <== NOT EXECUTED
40021678:	40 00 0e c1 	call  4002517c <printf>                        <== NOT EXECUTED
4002167c:	90 12 20 28 	or  %o0, 0x28, %o0	! 40039428 <CSWTCH.2+0x1638><== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, link, &inode, true);                 
40021680:	10 bf ff e9 	b  40021624 <rtems_rfs_symlink_read+0x20>      <== NOT EXECUTED
40021684:	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);            
40021688:	d4 0a 60 0a 	ldub  [ %o1 + 0xa ], %o2                       
  {                                                                   
    rtems_rfs_inode_close (fs, &inode);                               
    return EINVAL;                                                    
  }                                                                   
                                                                      
  *length = rtems_rfs_inode_get_block_offset (&inode);                
4002168c:	c2 0a 60 0b 	ldub  [ %o1 + 0xb ], %g1                       
40021690:	95 2a a0 08 	sll  %o2, 8, %o2                               
40021694:	94 10 40 0a 	or  %g1, %o2, %o2                              
40021698:	80 a2 80 1b 	cmp  %o2, %i3                                  
4002169c:	38 80 00 02 	bgu,a   400216a4 <rtems_rfs_symlink_read+0xa0> 
400216a0:	94 10 00 1b 	mov  %i3, %o2                                  
400216a4:	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);             
400216a8:	c8 0a 60 0c 	ldub  [ %o1 + 0xc ], %g4                       
400216ac:	c4 0a 60 0d 	ldub  [ %o1 + 0xd ], %g2                       
400216b0:	c6 0a 60 0f 	ldub  [ %o1 + 0xf ], %g3                       
400216b4:	c2 0a 60 0e 	ldub  [ %o1 + 0xe ], %g1                       
400216b8:	89 29 20 18 	sll  %g4, 0x18, %g4                            
400216bc:	85 28 a0 10 	sll  %g2, 0x10, %g2                            
400216c0:	83 28 60 08 	sll  %g1, 8, %g1                               
400216c4:	84 11 00 02 	or  %g4, %g2, %g2                              
400216c8:	84 10 80 03 	or  %g2, %g3, %g2                              
  if (size < *length)                                                 
  {                                                                   
    *length = size;                                                   
  }                                                                   
                                                                      
  if (rtems_rfs_inode_get_block_count (&inode) == 0)                  
400216cc:	80 90 80 01 	orcc  %g2, %g1, %g0                            
400216d0:	12 80 00 0a 	bne  400216f8 <rtems_rfs_symlink_read+0xf4>    <== NEVER TAKEN
400216d4:	90 10 00 18 	mov  %i0, %o0                                  
  {                                                                   
    memcpy (path, inode.node->data.name, *length);                    
400216d8:	90 10 00 1a 	mov  %i2, %o0                                  
400216dc:	40 00 0d 9b 	call  40024d48 <memcpy>                        
400216e0:	92 02 60 1c 	add  %o1, 0x1c, %o1                            
      rtems_rfs_inode_close (fs, &inode);                             
      return rc;                                                      
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_close (fs, &inode);                            
400216e4:	90 10 00 18 	mov  %i0, %o0                                  
400216e8:	7f ff c8 40 	call  400137e8 <rtems_rfs_inode_close>         
400216ec:	92 07 bf 88 	add  %fp, -120, %o1                            
400216f0:	10 bf ff df 	b  4002166c <rtems_rfs_symlink_read+0x68>      
400216f4:	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);                 
400216f8:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
400216fc:	7f ff ec 45 	call  4001c810 <rtems_rfs_block_map_open>      <== NOT EXECUTED
40021700:	94 07 bf b0 	add  %fp, -80, %o2                             <== NOT EXECUTED
40021704:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
    if (rc > 0)                                                       
40021708:	80 a7 60 00 	cmp  %i5, 0                                    <== NOT EXECUTED
4002170c:	04 80 00 05 	ble  40021720 <rtems_rfs_symlink_read+0x11c>   <== NOT EXECUTED
40021710:	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);                             
40021714:	7f ff c8 35 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40021718:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
4002171c:	30 bf ff d4 	b,a   4002166c <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);              
40021720:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
40021724:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
40021728:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
4002172c:	7f ff ed 68 	call  4001cccc <rtems_rfs_block_map_seek>      <== NOT EXECUTED
40021730:	98 07 bf 78 	add  %fp, -136, %o4                            <== NOT EXECUTED
    if (rc > 0)                                                       
40021734:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
40021738:	04 80 00 09 	ble  4002175c <rtems_rfs_symlink_read+0x158>   <== NOT EXECUTED
4002173c:	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);                           
40021740:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
40021744:	7f ff ec 94 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
40021748:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &inode);                             
4002174c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40021750:	7f ff c8 26 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40021754:	92 07 bf 88 	add  %fp, -120, %o1                            <== NOT EXECUTED
40021758:	30 bf ff c5 	b,a   4002166c <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;                                              
4002175c:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
40021760:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
40021764:	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); 
40021768:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4002176c:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
40021770:	7f ff f0 2c 	call  4001d820 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
40021774:	96 10 20 00 	clr  %o3                                       <== NOT EXECUTED
    if (rc > 0)                                                       
40021778:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
4002177c:	34 bf ff f2 	bg,a   40021744 <rtems_rfs_symlink_read+0x140> <== NOT EXECUTED
40021780:	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);                                     
40021784:	c2 07 bf 84 	ld  [ %fp + -124 ], %g1                        <== NOT EXECUTED
40021788:	d4 07 00 00 	ld  [ %i4 ], %o2                               <== NOT EXECUTED
4002178c:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        <== NOT EXECUTED
40021790:	40 00 0d 6e 	call  40024d48 <memcpy>                        <== NOT EXECUTED
40021794:	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);                       
40021798:	92 07 bf 7c 	add  %fp, -132, %o1                            <== NOT EXECUTED
4002179c:	7f ff ef a7 	call  4001d638 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
400217a0:	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);                        
400217a4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
  handle->dirty = false;                                              
400217a8:	c0 2f bf 7c 	clrb  [ %fp + -132 ]                           <== NOT EXECUTED
  handle->bnum  = 0;                                                  
400217ac:	c0 27 bf 80 	clr  [ %fp + -128 ]                            <== NOT EXECUTED
  handle->buffer = NULL;                                              
400217b0:	c0 27 bf 84 	clr  [ %fp + -124 ]                            <== NOT EXECUTED
400217b4:	7f ff ec 78 	call  4001c994 <rtems_rfs_block_map_close>     <== NOT EXECUTED
400217b8:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
    if (rc > 0)                                                       
400217bc:	ba 92 20 00 	orcc  %o0, 0, %i5                              <== NOT EXECUTED
400217c0:	04 bf ff c9 	ble  400216e4 <rtems_rfs_symlink_read+0xe0>    <== NOT EXECUTED
400217c4:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400217c8:	30 bf ff d3 	b,a   40021714 <rtems_rfs_symlink_read+0x110>  <== NOT EXECUTED
                                                                      

400150e4 <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;
400150e4:	03 10 01 2b 	sethi  %hi(0x4004ac00), %g1                    <== NOT EXECUTED
400150e8:	c4 18 60 90 	ldd  [ %g1 + 0x90 ], %g2	! 4004ac90 <rtems_rfs_trace_flags><== NOT EXECUTED
  rtems_rfs_trace_flags &= ~mask;                                     
400150ec:	98 28 80 08 	andn  %g2, %o0, %o4                            <== NOT EXECUTED
400150f0:	9a 28 c0 09 	andn  %g3, %o1, %o5                            <== NOT EXECUTED
  return state;                                                       
}                                                                     
400150f4:	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;                                     
400150f8:	d8 38 60 90 	std  %o4, [ %g1 + 0x90 ]                       <== NOT EXECUTED
  return state;                                                       
}                                                                     
400150fc:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
40015100:	92 10 00 03 	mov  %g3, %o1                                  <== NOT EXECUTED
                                                                      

400150c4 <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;
400150c4:	03 10 01 2b 	sethi  %hi(0x4004ac00), %g1                    <== NOT EXECUTED
400150c8:	c4 18 60 90 	ldd  [ %g1 + 0x90 ], %g2	! 4004ac90 <rtems_rfs_trace_flags><== NOT EXECUTED
  rtems_rfs_trace_flags |= mask;                                      
400150cc:	98 12 00 02 	or  %o0, %g2, %o4                              <== NOT EXECUTED
400150d0:	9a 12 40 03 	or  %o1, %g3, %o5                              <== NOT EXECUTED
  return state;                                                       
}                                                                     
400150d4:	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;                                      
400150d8:	d8 38 60 90 	std  %o4, [ %g1 + 0x90 ]                       <== NOT EXECUTED
  return state;                                                       
}                                                                     
400150dc:	81 c3 e0 08 	retl                                           <== NOT EXECUTED
400150e0:	92 10 00 03 	mov  %g3, %o1                                  <== NOT EXECUTED
                                                                      

40015104 <rtems_rfs_trace_shell_command>: int rtems_rfs_trace_shell_command (int argc, char *argv[]) {
40015104:	9d e3 bf 00 	save  %sp, -256, %sp                           <== NOT EXECUTED
  const char* table[] =                                               
40015108:	13 10 00 dd 	sethi  %hi(0x40037400), %o1                    <== NOT EXECUTED
4001510c:	a8 07 bf 64 	add  %fp, -156, %l4                            <== NOT EXECUTED
40015110:	92 12 61 0c 	or  %o1, 0x10c, %o1                            <== NOT EXECUTED
40015114:	90 10 00 14 	mov  %l4, %o0                                  <== NOT EXECUTED
40015118:	40 00 3f 0c 	call  40024d48 <memcpy>                        <== NOT EXECUTED
4001511c:	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++)                                    
40015120:	80 a6 20 01 	cmp  %i0, 1                                    <== NOT EXECUTED
40015124:	04 80 00 3f 	ble  40015220 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
40015128:	01 00 00 00 	nop                                            <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
4001512c:	e4 06 60 04 	ld  [ %i1 + 4 ], %l2                           <== NOT EXECUTED
40015130:	c2 4c 80 00 	ldsb  [ %l2 ], %g1                             <== NOT EXECUTED
40015134:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
40015138:	02 80 00 6e 	be  400152f0 <rtems_rfs_trace_shell_command+0x1ec><== NOT EXECUTED
4001513c:	2f 10 01 2b 	sethi  %hi(0x4004ac00), %l7                    <== NOT EXECUTED
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
40015140:	a6 10 20 01 	mov  1, %l3                                    <== NOT EXECUTED
40015144:	f8 1d e0 90 	ldd  [ %l7 + 0x90 ], %i4                       <== NOT EXECUTED
    "file-set"                                                        
  };                                                                  
                                                                      
  rtems_rfs_trace_mask set_value = 0;                                 
  rtems_rfs_trace_mask clear_value = 0;                               
  bool                 set = true;                                    
40015148:	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;                               
4001514c:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
40015150:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
    "file-close",                                                     
    "file-io",                                                        
    "file-set"                                                        
  };                                                                  
                                                                      
  rtems_rfs_trace_mask set_value = 0;                                 
40015154:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
40015158:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
4001515c:	10 80 00 10 	b  4001519c <rtems_rfs_trace_shell_command+0x98><== NOT EXECUTED
40015160:	ae 15 e0 90 	or  %l7, 0x90, %l7                             <== NOT EXECUTED
40015164:	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;                                                  
40015168:	aa 10 20 00 	clr  %l5                                       <== NOT EXECUTED
4001516c:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
40015170:	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++)                                    
40015174:	a6 04 e0 01 	inc  %l3                                       <== NOT EXECUTED
40015178:	80 a4 c0 18 	cmp  %l3, %i0                                  <== NOT EXECUTED
4001517c:	02 80 00 29 	be  40015220 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
40015180:	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[])                
40015184:	83 2c e0 02 	sll  %l3, 2, %g1                               <== NOT EXECUTED
  int                  arg;                                           
  int                  t;                                             
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
  {                                                                   
    if (argv[arg][0] == '-')                                          
40015188:	e4 06 40 01 	ld  [ %i1 + %g1 ], %l2                         <== NOT EXECUTED
4001518c:	c2 4c 80 00 	ldsb  [ %l2 ], %g1                             <== NOT EXECUTED
40015190:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
40015194:	22 80 00 58 	be,a   400152f4 <rtems_rfs_trace_shell_command+0x1f0><== NOT EXECUTED
40015198:	c2 4c a0 01 	ldsb  [ %l2 + 1 ], %g1                         <== NOT EXECUTED
          return 1;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (strcmp (argv[arg], "set") == 0)                             
4001519c:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
400151a0:	13 10 00 d5 	sethi  %hi(0x40035400), %o1                    <== NOT EXECUTED
400151a4:	40 00 42 7d 	call  40025b98 <strcmp>                        <== NOT EXECUTED
400151a8:	92 12 60 68 	or  %o1, 0x68, %o1	! 40035468 <Callbacks.6428+0x220><== NOT EXECUTED
400151ac:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400151b0:	22 80 00 02 	be,a   400151b8 <rtems_rfs_trace_shell_command+0xb4><== NOT EXECUTED
400151b4:	aa 10 20 01 	mov  1, %l5                                    <== NOT EXECUTED
        set = true;                                                   
      if (strcmp (argv[arg], "clear") == 0)                           
400151b8:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
400151bc:	13 10 00 dc 	sethi  %hi(0x40037000), %o1                    <== NOT EXECUTED
400151c0:	40 00 42 76 	call  40025b98 <strcmp>                        <== NOT EXECUTED
400151c4:	92 12 62 a0 	or  %o1, 0x2a0, %o1	! 400372a0 <rtems_rfs_rtems_eval_config+0xa0><== NOT EXECUTED
400151c8:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400151cc:	22 bf ff e6 	be,a   40015164 <rtems_rfs_trace_shell_command+0x60><== NOT EXECUTED
400151d0:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
        set = false;                                                  
      else if (strcmp (argv[arg], "all") == 0)                        
400151d4:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
400151d8:	13 10 00 dc 	sethi  %hi(0x40037000), %o1                    <== NOT EXECUTED
400151dc:	40 00 42 6f 	call  40025b98 <strcmp>                        <== NOT EXECUTED
400151e0:	92 12 62 a8 	or  %o1, 0x2a8, %o1	! 400372a8 <rtems_rfs_rtems_eval_config+0xa8><== NOT EXECUTED
400151e4:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
400151e8:	12 80 00 13 	bne  40015234 <rtems_rfs_trace_shell_command+0x130><== NOT EXECUTED
400151ec:	ac 10 20 00 	clr  %l6                                       <== NOT EXECUTED
      {                                                               
        if (set)                                                      
400151f0:	80 8d 60 ff 	btst  0xff, %l5                                <== NOT EXECUTED
400151f4:	22 80 00 23 	be,a   40015280 <rtems_rfs_trace_shell_command+0x17c><== NOT EXECUTED
400151f8:	35 3f ff ff 	sethi  %hi(0xfffffc00), %i2                    <== NOT EXECUTED
400151fc:	b8 3e a0 00 	xnor  %i2, 0, %i4                              <== NOT EXECUTED
40015200:	ba 3e e0 00 	xnor  %i3, 0, %i5                              <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      rtems_rfs_trace_flags |= set_value;                             
      rtems_rfs_trace_flags &= ~clear_value;                          
40015204:	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;                            
40015208:	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++)                                    
4001520c:	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;                            
40015210:	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++)                                    
40015214:	80 a4 c0 18 	cmp  %l3, %i0                                  <== NOT EXECUTED
40015218:	12 bf ff db 	bne  40015184 <rtems_rfs_trace_shell_command+0x80><== NOT EXECUTED
4001521c:	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;                                                   
40015220:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015224:	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++) 
40015228:	80 a5 a0 27 	cmp  %l6, 0x27                                 <== NOT EXECUTED
4001522c:	22 80 00 11 	be,a   40015270 <rtems_rfs_trace_shell_command+0x16c><== NOT EXECUTED
40015230:	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[])                
40015234:	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)                      
40015238:	d2 05 00 02 	ld  [ %l4 + %g2 ], %o1                         <== NOT EXECUTED
4001523c:	40 00 42 57 	call  40025b98 <strcmp>                        <== NOT EXECUTED
40015240:	90 10 00 12 	mov  %l2, %o0                                  <== NOT EXECUTED
40015244:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
40015248:	32 bf ff f8 	bne,a   40015228 <rtems_rfs_trace_shell_command+0x124><== NOT EXECUTED
4001524c:	ac 05 a0 01 	inc  %l6                                       <== NOT EXECUTED
          {                                                           
            if (set)                                                  
40015250:	80 8d 60 ff 	btst  0xff, %l5                                <== NOT EXECUTED
40015254:	02 80 00 10 	be  40015294 <rtems_rfs_trace_shell_command+0x190><== NOT EXECUTED
40015258:	80 8d a0 20 	btst  0x20, %l6                                <== NOT EXECUTED
              set_value = 1ULL << t;                                  
4001525c:	12 80 00 1e 	bne  400152d4 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
40015260:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
40015264:	a0 10 20 00 	clr  %l0                                       <== NOT EXECUTED
40015268:	a3 28 40 16 	sll  %g1, %l6, %l1                             <== NOT EXECUTED
4001526c:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
40015270:	ba 14 40 1d 	or  %l1, %i5, %i5                              <== NOT EXECUTED
40015274:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
40015278:	10 bf ff bf 	b  40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
4001527c:	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)                                                      
40015280:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
          set_value = RTEMS_RFS_TRACE_ALL;                            
        else                                                          
          clear_value = RTEMS_RFS_TRACE_ALL;                          
40015284:	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)                                                      
40015288:	ba 10 20 00 	clr  %i5                                       <== NOT EXECUTED
          set_value = RTEMS_RFS_TRACE_ALL;                            
        else                                                          
          clear_value = RTEMS_RFS_TRACE_ALL;                          
4001528c:	10 bf ff ba 	b  40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
40015290:	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;                                
40015294:	12 80 00 09 	bne  400152b8 <rtems_rfs_trace_shell_command+0x1b4><== NOT EXECUTED
40015298:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4001529c:	b4 10 20 00 	clr  %i2                                       <== NOT EXECUTED
400152a0:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
400152a4:	b7 28 40 16 	sll  %g1, %l6, %i3                             <== NOT EXECUTED
400152a8:	ba 14 40 1d 	or  %l1, %i5, %i5                              <== NOT EXECUTED
400152ac:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
400152b0:	10 bf ff b1 	b  40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400152b4:	ba 2f 40 1b 	andn  %i5, %i3, %i5                            <== NOT EXECUTED
400152b8:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
400152bc:	b5 28 40 16 	sll  %g1, %l6, %i2                             <== NOT EXECUTED
400152c0:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
400152c4:	ba 14 40 1d 	or  %l1, %i5, %i5                              <== NOT EXECUTED
400152c8:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
400152cc:	10 bf ff aa 	b  40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400152d0:	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;                                  
400152d4:	a2 10 20 00 	clr  %l1                                       <== NOT EXECUTED
400152d8:	a1 28 40 16 	sll  %g1, %l6, %l0                             <== NOT EXECUTED
400152dc:	ba 14 40 1d 	or  %l1, %i5, %i5                              <== NOT EXECUTED
400152e0:	b8 14 00 1c 	or  %l0, %i4, %i4                              <== NOT EXECUTED
400152e4:	ba 2f 40 1b 	andn  %i5, %i3, %i5                            <== NOT EXECUTED
400152e8:	10 bf ff a3 	b  40015174 <rtems_rfs_trace_shell_command+0x70><== NOT EXECUTED
400152ec:	b8 2f 00 1a 	andn  %i4, %i2, %i4                            <== NOT EXECUTED
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
  {                                                                   
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
400152f0:	c2 4c a0 01 	ldsb  [ %l2 + 1 ], %g1                         <== NOT EXECUTED
400152f4:	80 a0 60 68 	cmp  %g1, 0x68                                 <== NOT EXECUTED
400152f8:	02 80 00 09 	be  4001531c <rtems_rfs_trace_shell_command+0x218><== NOT EXECUTED
400152fc:	80 a0 60 6c 	cmp  %g1, 0x6c                                 <== NOT EXECUTED
40015300:	02 80 00 0e 	be  40015338 <rtems_rfs_trace_shell_command+0x234><== NOT EXECUTED
40015304:	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");                         
40015308:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
4001530c:	40 00 40 34 	call  400253dc <puts>                          <== NOT EXECUTED
40015310:	90 12 22 88 	or  %o0, 0x288, %o0	! 40037288 <rtems_rfs_rtems_eval_config+0x88><== NOT EXECUTED
40015314:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015318:	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]);  
4001531c:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
40015320:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
          return 0;                                                   
40015324:	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]);  
40015328:	40 00 3f 95 	call  4002517c <printf>                        <== NOT EXECUTED
4001532c:	90 12 22 30 	or  %o0, 0x230, %o0                            <== NOT EXECUTED
40015330:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015334:	81 e8 00 00 	restore                                        <== NOT EXECUTED
          return 0;                                                   
        case 'l':                                                     
          printf ("%s: valid flags to set or clear are:\n", argv[0]); 
40015338:	d2 06 40 00 	ld  [ %i1 ], %o1                               <== NOT EXECUTED
4001533c:	11 10 00 dc 	sethi  %hi(0x40037000), %o0                    <== NOT EXECUTED
40015340:	3b 10 00 dc 	sethi  %hi(0x40037000), %i5                    <== NOT EXECUTED
40015344:	90 12 22 58 	or  %o0, 0x258, %o0                            <== NOT EXECUTED
40015348:	40 00 3f 8d 	call  4002517c <printf>                        <== NOT EXECUTED
4001534c:	b8 10 00 1e 	mov  %fp, %i4                                  <== NOT EXECUTED
          for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
            printf ("  %s\n", table[t]);                              
40015350:	ba 17 62 80 	or  %i5, 0x280, %i5                            <== NOT EXECUTED
40015354:	d2 05 00 00 	ld  [ %l4 ], %o1                               <== NOT EXECUTED
40015358:	40 00 3f 89 	call  4002517c <printf>                        <== NOT EXECUTED
4001535c:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40015360:	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++)
40015364:	80 a5 00 1c 	cmp  %l4, %i4                                  <== NOT EXECUTED
40015368:	32 bf ff fc 	bne,a   40015358 <rtems_rfs_trace_shell_command+0x254><== NOT EXECUTED
4001536c:	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;                                                   
40015370:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40015374:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
40015378:	40 01 63 f4 	call  4006e348 <__end+0x225f8>                 <== NOT EXECUTED
4001537c:	40 01 65 90 	call  4006e9bc <__end+0x22c6c>                 <== NOT EXECUTED
40015380:	40 01 65 88 	call  4006e9a0 <__end+0x22c50>                 <== NOT EXECUTED
40015384:	40 01 65 74 	call  4006e954 <__end+0x22c04>                 <== NOT EXECUTED
40015388:	40 01 65 74 	call  4006e958 <__end+0x22c08>                 <== NOT EXECUTED
4001538c:	40 01 65 74 	call  4006e95c <__end+0x22c0c>                 <== NOT EXECUTED
40015390:	40 01 65 74 	call  4006e960 <__end+0x22c10>                 <== NOT EXECUTED
40015394:	40 01 65 40 	call  4006e894 <__end+0x22b44>                 <== NOT EXECUTED
40015398:	40 01 65 2c 	call  4006e848 <__end+0x22af8>                 <== NOT EXECUTED
4001539c:	40 01 65 2c 	call  4006e84c <__end+0x22afc>                 <== NOT EXECUTED
400153a0:	40 01 65 2c 	call  4006e850 <__end+0x22b00>                 <== NOT EXECUTED
400153a4:	40 01 64 3c 	call  4006e494 <__end+0x22744>                 <== NOT EXECUTED
400153a8:	40 01 64 2c 	call  4006e458 <__end+0x22708>                 <== NOT EXECUTED
400153ac:	40 01 64 2c 	call  4006e45c <__end+0x2270c>                 <== NOT EXECUTED
400153b0:	40 01 65 08 	call  4006e7d0 <__end+0x22a80>                 <== NOT EXECUTED
400153b4:	40 01 65 08 	call  4006e7d4 <__end+0x22a84>                 <== NOT EXECUTED
400153b8:	40 01 65 08 	call  4006e7d8 <__end+0x22a88>                 <== NOT EXECUTED
400153bc:	40 01 65 08 	call  4006e7dc <__end+0x22a8c>                 <== NOT EXECUTED
400153c0:	40 01 64 d4 	call  4006e710 <__end+0x229c0>                 <== NOT EXECUTED
400153c4:	40 01 64 c0 	call  4006e6c4 <__end+0x22974>                 <== NOT EXECUTED
400153c8:	40 01 64 c0 	call  4006e6c8 <__end+0x22978>                 <== NOT EXECUTED
400153cc:	40 01 64 c0 	call  4006e6cc <__end+0x2297c>                 <== NOT EXECUTED
400153d0:	40 01 7a 40 	call  40073cd0 <__end+0x27f80>                 <== NOT EXECUTED
400153d4:	40 01 7a 40 	call  40073cd4 <__end+0x27f84>                 <== NOT EXECUTED
400153d8:	40 01 7b 68 	call  40074178 <__end+0x28428>                 <== NOT EXECUTED
400153dc:	40 01 7b 90 	call  4007421c <__end+0x284cc>                 <== NOT EXECUTED
400153e0:	40 01 7b 90 	call  40074220 <__end+0x284d0>                 <== NOT EXECUTED
400153e4:	40 01 7b 90 	call  40074224 <__end+0x284d4>                 <== NOT EXECUTED
400153e8:	40 01 7a 40 	call  40073ce8 <__end+0x27f98>                 <== NOT EXECUTED
400153ec:	40 01 7b 58 	call  4007414c <__end+0x283fc>                 <== NOT EXECUTED
400153f0:	40 01 7b 50 	call  40074130 <__end+0x283e0>                 <== NOT EXECUTED
400153f4:	40 01 7b 98 	call  40074254 <__end+0x28504>                 <== NOT EXECUTED
400153f8:	40 01 7a 40 	call  40073cf8 <__end+0x27fa8>                 <== NOT EXECUTED
                                                                      

40020f68 <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) {
40020f68:	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))                       
40020f6c:	90 10 20 00 	clr  %o0                                       
40020f70:	7f ff d0 4d 	call  400150a4 <rtems_rfs_trace>               
40020f74:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     
40020f78:	80 8a 20 ff 	btst  0xff, %o0                                
40020f7c:	12 80 00 4a 	bne  400210a4 <rtems_rfs_unlink+0x13c>         <== NEVER TAKEN
40020f80:	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);        
40020f84:	90 10 00 18 	mov  %i0, %o0                                  
40020f88:	92 10 00 1a 	mov  %i2, %o1                                  
40020f8c:	94 07 bf d8 	add  %fp, -40, %o2                             
40020f90:	7f ff c9 9e 	call  40013608 <rtems_rfs_inode_open>          
40020f94:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40020f98:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40020f9c:	12 80 00 19 	bne  40021000 <rtems_rfs_unlink+0x98>          <== NEVER TAKEN
40020fa0:	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)); 
40020fa4:	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);                    
40020fa8:	c2 08 60 02 	ldub  [ %g1 + 2 ], %g1                         
40020fac:	83 28 60 08 	sll  %g1, 8, %g1                               
40020fb0:	82 08 40 02 	and  %g1, %g2, %g1                             
40020fb4:	05 00 00 10 	sethi  %hi(0x4000), %g2                        
40020fb8:	82 18 40 02 	xor  %g1, %g2, %g1                             
  if (dir)                                                            
40020fbc:	80 a0 00 01 	cmp  %g0, %g1                                  
40020fc0:	a0 60 3f ff 	subx  %g0, -1, %l0                             
40020fc4:	80 a4 20 00 	cmp  %l0, 0                                    
40020fc8:	02 80 00 12 	be  40021010 <rtems_rfs_unlink+0xa8>           
40020fcc:	80 a7 20 00 	cmp  %i4, 0                                    
  {                                                                   
    switch (dir_mode)                                                 
40020fd0:	12 80 00 0e 	bne  40021008 <rtems_rfs_unlink+0xa0>          <== ALWAYS TAKEN
40020fd4:	80 a7 20 01 	cmp  %i4, 1                                    
    {                                                                 
      case rtems_rfs_unlink_dir_denied:                               
        if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                 
40020fd8:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
40020fdc:	7f ff d0 32 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40020fe0:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
40020fe4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40020fe8:	12 80 00 5a 	bne  40021150 <rtems_rfs_unlink+0x1e8>         <== NOT EXECUTED
40020fec:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
          printf ("rtems-rfs: link is a directory\n");                
        rtems_rfs_inode_close (fs, &target_inode);                    
40020ff0:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40020ff4:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40020ff8:	7f ff c9 fc 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40020ffc:	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;                                                          
}                                                                     
40021000:	81 c7 e0 08 	ret                                            
40021004:	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)                                                 
40021008:	02 80 00 3f 	be  40021104 <rtems_rfs_unlink+0x19c>          <== ALWAYS TAKEN
4002100c:	90 10 00 18 	mov  %i0, %o0                                  
      default:                                                        
        break;                                                        
    }                                                                 
  }                                                                   
                                                                      
  rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);        
40021010:	90 10 00 18 	mov  %i0, %o0                                  
40021014:	92 10 00 19 	mov  %i1, %o1                                  
40021018:	94 07 bf b0 	add  %fp, -80, %o2                             
4002101c:	7f ff c9 7b 	call  40013608 <rtems_rfs_inode_open>          
40021020:	96 10 20 01 	mov  1, %o3                                    
  if (rc)                                                             
40021024:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021028:	12 80 00 25 	bne  400210bc <rtems_rfs_unlink+0x154>         <== NEVER TAKEN
4002102c:	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);     
40021030:	90 10 00 18 	mov  %i0, %o0                                  
40021034:	92 07 bf b0 	add  %fp, -80, %o1                             
40021038:	94 10 00 1a 	mov  %i2, %o2                                  
4002103c:	7f ff f6 43 	call  4001e948 <rtems_rfs_dir_del_entry>       
40021040:	96 10 00 1b 	mov  %i3, %o3                                  
  if (rc > 0)                                                         
40021044:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021048:	04 80 00 46 	ble  40021160 <rtems_rfs_unlink+0x1f8>         <== ALWAYS TAKEN
4002104c:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
40021050:	7f ff d0 15 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
40021054:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
40021058:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
4002105c:	02 80 00 0a 	be  40021084 <rtems_rfs_unlink+0x11c>          <== NOT EXECUTED
40021060:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
      printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",          
40021064:	40 00 14 90 	call  400262a4 <strerror>                      <== NOT EXECUTED
40021068:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
4002106c:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40021070:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40021074:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40021078:	40 00 10 41 	call  4002517c <printf>                        <== NOT EXECUTED
4002107c:	90 12 22 c8 	or  %o0, 0x2c8, %o0	! 400392c8 <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);                        
40021080:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
40021084:	7f ff c9 d9 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40021088:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
    rtems_rfs_inode_close (fs, &target_inode);                        
4002108c:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
40021090:	92 07 bf d8 	add  %fp, -40, %o1                             <== NOT EXECUTED
40021094:	7f ff c9 d5 	call  400137e8 <rtems_rfs_inode_close>         <== NOT EXECUTED
40021098:	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;                                                          
}                                                                     
4002109c:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400210a0:	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);
400210a4:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
400210a8:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
400210ac:	40 00 10 34 	call  4002517c <printf>                        <== NOT EXECUTED
400210b0:	90 12 22 28 	or  %o0, 0x228, %o0                            <== NOT EXECUTED
                                                                      
  rc = rtems_rfs_inode_open (fs, target, &target_inode, true);        
400210b4:	10 bf ff b5 	b  40020f88 <rtems_rfs_unlink+0x20>            <== NOT EXECUTED
400210b8:	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))                     
400210bc:	7f ff cf fa 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400210c0:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
400210c4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400210c8:	22 80 00 0a 	be,a   400210f0 <rtems_rfs_unlink+0x188>       <== NOT EXECUTED
400210cc:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: link: inode-open failed: %d: %s\n",         
400210d0:	40 00 14 75 	call  400262a4 <strerror>                      <== NOT EXECUTED
400210d4:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400210d8:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400210dc:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
400210e0:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
400210e4:	40 00 10 26 	call  4002517c <printf>                        <== NOT EXECUTED
400210e8:	90 12 22 98 	or  %o0, 0x298, %o0	! 40039298 <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);                        
400210ec:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
400210f0:	92 07 bf d8 	add  %fp, -40, %o1                             
400210f4:	7f ff c9 bd 	call  400137e8 <rtems_rfs_inode_close>         
400210f8:	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;                                                          
}                                                                     
400210fc:	81 c7 e0 08 	ret                                            
40021100:	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);                 
40021104:	7f ff f8 14 	call  4001f154 <rtems_rfs_dir_empty>           
40021108:	92 07 bf d8 	add  %fp, -40, %o1                             
        if (rc > 0)                                                   
4002110c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021110:	04 bf ff c0 	ble  40021010 <rtems_rfs_unlink+0xa8>          
40021114:	90 10 20 00 	clr  %o0                                       
        {                                                             
          if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))               
40021118:	7f ff cf e3 	call  400150a4 <rtems_rfs_trace>               
4002111c:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     
40021120:	80 8a 20 ff 	btst  0xff, %o0                                
40021124:	22 bf ff f3 	be,a   400210f0 <rtems_rfs_unlink+0x188>       <== ALWAYS TAKEN
40021128:	90 10 00 18 	mov  %i0, %o0                                  
            printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
4002112c:	40 00 14 5e 	call  400262a4 <strerror>                      <== NOT EXECUTED
40021130:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021134:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40021138:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4002113c:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40021140:	40 00 10 0f 	call  4002517c <printf>                        <== NOT EXECUTED
40021144:	90 12 22 78 	or  %o0, 0x278, %o0	! 40039278 <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);                        
40021148:	10 bf ff ea 	b  400210f0 <rtems_rfs_unlink+0x188>           <== NOT EXECUTED
4002114c:	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");                
40021150:	40 00 10 a3 	call  400253dc <puts>                          <== NOT EXECUTED
40021154:	90 12 22 58 	or  %o0, 0x258, %o0                            <== NOT EXECUTED
        rtems_rfs_inode_close (fs, &target_inode);                    
40021158:	10 bf ff a7 	b  40020ff4 <rtems_rfs_unlink+0x8c>            <== NOT EXECUTED
4002115c:	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);                  
40021160:	c4 07 bf e4 	ld  [ %fp + -28 ], %g2                         
  if (links == 0xffff)                                                
    links = 0;                                                        
40021164:	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);                  
40021168:	c2 08 80 00 	ldub  [ %g2 ], %g1                             
4002116c:	c4 08 a0 01 	ldub  [ %g2 + 1 ], %g2                         
40021170:	83 28 60 08 	sll  %g1, 8, %g1                               
40021174:	82 10 40 02 	or  %g1, %g2, %g1                              
  if (links == 0xffff)                                                
40021178:	85 28 60 10 	sll  %g1, 0x10, %g2                            
4002117c:	85 30 a0 10 	srl  %g2, 0x10, %g2                            
    links = 0;                                                        
40021180:	84 38 c0 02 	xnor  %g3, %g2, %g2                            
40021184:	80 a0 00 02 	cmp  %g0, %g2                                  
40021188:	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))                       
4002118c:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     
40021190:	7f ff cf c5 	call  400150a4 <rtems_rfs_trace>               
40021194:	ba 08 40 1d 	and  %g1, %i5, %i5                             
40021198:	80 8a 20 ff 	btst  0xff, %o0                                
4002119c:	12 80 00 22 	bne  40021224 <rtems_rfs_unlink+0x2bc>         <== NEVER TAKEN
400211a0:	b9 2f 60 10 	sll  %i5, 0x10, %i4                            
    printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
                                                                      
  if (links > 1)                                                      
400211a4:	b9 37 20 10 	srl  %i4, 0x10, %i4                            
400211a8:	80 a7 20 01 	cmp  %i4, 1                                    
400211ac:	08 80 00 39 	bleu  40021290 <rtems_rfs_unlink+0x328>        
400211b0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
  {                                                                   
    links--;                                                          
400211b4:	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);                  
400211b8:	85 37 60 08 	srl  %i5, 8, %g2                               
400211bc:	c4 28 40 00 	stb  %g2, [ %g1 ]                              
400211c0:	c2 07 bf e4 	ld  [ %fp + -28 ], %g1                         
400211c4:	fa 28 60 01 	stb  %i5, [ %g1 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
400211c8:	82 10 20 01 	mov  1, %g1                                    
400211cc:	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);    
400211d0:	90 07 bf b0 	add  %fp, -80, %o0                             
400211d4:	92 10 20 01 	mov  1, %o1                                    
400211d8:	7f ff c9 df 	call  40013954 <rtems_rfs_inode_time_stamp_now>
400211dc:	94 10 20 01 	mov  1, %o2                                    
  if (rc > 0)                                                         
400211e0:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400211e4:	04 80 00 17 	ble  40021240 <rtems_rfs_unlink+0x2d8>         <== ALWAYS TAKEN
400211e8:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
400211ec:	7f ff cf ae 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400211f0:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
400211f4:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400211f8:	22 bf ff a3 	be,a   40021084 <rtems_rfs_unlink+0x11c>       <== NOT EXECUTED
400211fc:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
      printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",   
40021200:	40 00 14 29 	call  400262a4 <strerror>                      <== NOT EXECUTED
40021204:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021208:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
4002120c:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40021210:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40021214:	40 00 0f da 	call  4002517c <printf>                        <== NOT EXECUTED
40021218:	90 12 23 50 	or  %o0, 0x350, %o0	! 40039350 <CSWTCH.2+0x1560><== NOT EXECUTED
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &parent_inode);                        
4002121c:	10 bf ff 9a 	b  40021084 <rtems_rfs_unlink+0x11c>           <== NOT EXECUTED
40021220:	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);
40021224:	92 10 00 1a 	mov  %i2, %o1                                  <== NOT EXECUTED
40021228:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
4002122c:	95 37 20 10 	srl  %i4, 0x10, %o2                            <== NOT EXECUTED
40021230:	40 00 0f d3 	call  4002517c <printf>                        <== NOT EXECUTED
40021234:	90 12 22 f8 	or  %o0, 0x2f8, %o0                            <== NOT EXECUTED
                                                                      
  if (links > 1)                                                      
40021238:	10 bf ff dc 	b  400211a8 <rtems_rfs_unlink+0x240>           <== NOT EXECUTED
4002123c:	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);                     
40021240:	90 10 00 18 	mov  %i0, %o0                                  
40021244:	7f ff c9 69 	call  400137e8 <rtems_rfs_inode_close>         
40021248:	92 07 bf b0 	add  %fp, -80, %o1                             
  if (rc > 0)                                                         
4002124c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40021250:	04 80 00 24 	ble  400212e0 <rtems_rfs_unlink+0x378>         <== ALWAYS TAKEN
40021254:	90 10 20 00 	clr  %o0                                       
  {                                                                   
    if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                     
40021258:	7f ff cf 93 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
4002125c:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
40021260:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021264:	22 bf ff a3 	be,a   400210f0 <rtems_rfs_unlink+0x188>       <== NOT EXECUTED
40021268:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
      printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n", 
4002126c:	40 00 14 0e 	call  400262a4 <strerror>                      <== NOT EXECUTED
40021270:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021274:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40021278:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4002127c:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40021280:	40 00 0f bf 	call  4002517c <printf>                        <== NOT EXECUTED
40021284:	90 12 23 88 	or  %o0, 0x388, %o0	! 40039388 <CSWTCH.2+0x1598><== NOT EXECUTED
              rc, strerror (rc));                                     
    rtems_rfs_inode_close (fs, &target_inode);                        
40021288:	10 bf ff 9a 	b  400210f0 <rtems_rfs_unlink+0x188>           <== NOT EXECUTED
4002128c:	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);                  
40021290:	90 10 00 18 	mov  %i0, %o0                                  
40021294:	7f ff c9 7b 	call  40013880 <rtems_rfs_inode_delete>        
40021298:	92 07 bf d8 	add  %fp, -40, %o1                             
    if (rc > 0)                                                       
4002129c:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400212a0:	04 80 00 23 	ble  4002132c <rtems_rfs_unlink+0x3c4>         <== ALWAYS TAKEN
400212a4:	90 10 20 00 	clr  %o0                                       
    {                                                                 
      if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))                   
400212a8:	7f ff cf 7f 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400212ac:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
400212b0:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
400212b4:	22 bf ff 74 	be,a   40021084 <rtems_rfs_unlink+0x11c>       <== NOT EXECUTED
400212b8:	92 07 bf b0 	add  %fp, -80, %o1                             <== NOT EXECUTED
        printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",      
400212bc:	40 00 13 fa 	call  400262a4 <strerror>                      <== NOT EXECUTED
400212c0:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
400212c4:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
400212c8:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
400212cc:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
400212d0:	40 00 0f ab 	call  4002517c <printf>                        <== NOT EXECUTED
400212d4:	90 12 23 20 	or  %o0, 0x320, %o0	! 40039320 <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);                        
400212d8:	10 bf ff 6b 	b  40021084 <rtems_rfs_unlink+0x11c>           <== NOT EXECUTED
400212dc:	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);                     
400212e0:	90 10 00 18 	mov  %i0, %o0                                  
400212e4:	7f ff c9 41 	call  400137e8 <rtems_rfs_inode_close>         
400212e8:	92 07 bf d8 	add  %fp, -40, %o1                             
                                                                      
  if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))           
400212ec:	ba 92 20 00 	orcc  %o0, 0, %i5                              
400212f0:	04 bf ff 44 	ble  40021000 <rtems_rfs_unlink+0x98>          <== ALWAYS TAKEN
400212f4:	90 10 20 00 	clr  %o0                                       
400212f8:	7f ff cf 6b 	call  400150a4 <rtems_rfs_trace>               <== NOT EXECUTED
400212fc:	13 00 80 00 	sethi  %hi(0x2000000), %o1                     <== NOT EXECUTED
40021300:	80 8a 20 ff 	btst  0xff, %o0                                <== NOT EXECUTED
40021304:	02 bf ff 3f 	be  40021000 <rtems_rfs_unlink+0x98>           <== NOT EXECUTED
40021308:	01 00 00 00 	nop                                            <== NOT EXECUTED
    printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",   
4002130c:	40 00 13 e6 	call  400262a4 <strerror>                      <== NOT EXECUTED
40021310:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40021314:	92 10 00 1d 	mov  %i5, %o1                                  <== NOT EXECUTED
40021318:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
4002131c:	11 10 00 e4 	sethi  %hi(0x40039000), %o0                    <== NOT EXECUTED
40021320:	40 00 0f 97 	call  4002517c <printf>                        <== NOT EXECUTED
40021324:	90 12 23 c0 	or  %o0, 0x3c0, %o0	! 400393c0 <CSWTCH.2+0x15d0><== NOT EXECUTED
40021328:	30 bf ff 36 	b,a   40021000 <rtems_rfs_unlink+0x98>         <== NOT EXECUTED
      rtems_rfs_inode_close (fs, &parent_inode);                      
      rtems_rfs_inode_close (fs, &target_inode);                      
      return rc;                                                      
    }                                                                 
                                                                      
    if (dir)                                                          
4002132c:	80 a4 20 00 	cmp  %l0, 0                                    
40021330:	02 bf ff a9 	be  400211d4 <rtems_rfs_unlink+0x26c>          
40021334:	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);                  
40021338:	c4 07 bf bc 	ld  [ %fp + -68 ], %g2                         
  if (links == 0xffff)                                                
4002133c:	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);                  
40021340:	c2 08 a0 01 	ldub  [ %g2 + 1 ], %g1                         
40021344:	c6 08 80 00 	ldub  [ %g2 ], %g3                             
  if (links == 0xffff)                                                
40021348:	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);                  
4002134c:	87 28 e0 08 	sll  %g3, 8, %g3                               
40021350:	86 10 c0 01 	or  %g3, %g1, %g3                              
  if (links == 0xffff)                                                
40021354:	89 28 e0 10 	sll  %g3, 0x10, %g4                            
40021358:	89 31 20 10 	srl  %g4, 0x10, %g4                            
4002135c:	80 a1 00 1d 	cmp  %g4, %i5                                  
40021360:	02 80 00 0c 	be  40021390 <rtems_rfs_unlink+0x428>          <== NEVER TAKEN
40021364:	82 10 00 03 	mov  %g3, %g1                                  
    {                                                                 
      links = rtems_rfs_inode_get_links (&parent_inode);              
      if (links > 1)                                                  
40021368:	80 a1 20 01 	cmp  %g4, 1                                    
4002136c:	38 80 00 02 	bgu,a   40021374 <rtems_rfs_unlink+0x40c>      
40021370:	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);                  
40021374:	87 30 60 08 	srl  %g1, 8, %g3                               
40021378:	c6 28 80 00 	stb  %g3, [ %g2 ]                              
4002137c:	c4 07 bf bc 	ld  [ %fp + -68 ], %g2                         
40021380:	c2 28 a0 01 	stb  %g1, [ %g2 + 1 ]                          
  rtems_rfs_buffer_mark_dirty (&handle->buffer);                      
40021384:	82 10 20 01 	mov  1, %g1                                    
40021388:	10 bf ff 92 	b  400211d0 <rtems_rfs_unlink+0x268>           
4002138c:	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;                                                        
40021390:	10 bf ff f9 	b  40021374 <rtems_rfs_unlink+0x40c>           <== NOT EXECUTED
40021394:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

40024844 <rtems_shell_rfs_format>: return 1; } int rtems_shell_rfs_format (int argc, char* argv[]) {
40024844:	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));              
40024848:	c0 27 bf e8 	clr  [ %fp + -24 ]                             <== NOT EXECUTED
4002484c:	c0 27 bf ec 	clr  [ %fp + -20 ]                             <== NOT EXECUTED
40024850:	c0 27 bf f0 	clr  [ %fp + -16 ]                             <== NOT EXECUTED
40024854:	c0 27 bf f4 	clr  [ %fp + -12 ]                             <== NOT EXECUTED
40024858:	c0 27 bf f8 	clr  [ %fp + -8 ]                              <== NOT EXECUTED
4002485c:	c0 27 bf fc 	clr  [ %fp + -4 ]                              <== NOT EXECUTED
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
40024860:	ba 10 20 01 	mov  1, %i5                                    <== NOT EXECUTED
40024864:	b8 10 20 00 	clr  %i4                                       <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
40024868:	37 10 00 8c 	sethi  %hi(0x40023000), %i3                    <== NOT EXECUTED
  const char*             driver = NULL;                              
  int                     arg;                                        
                                                                      
  memset (&config, 0, sizeof (rtems_rfs_format_config));              
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
4002486c:	80 a6 20 01 	cmp  %i0, 1                                    <== NOT EXECUTED
40024870:	14 80 00 0a 	bg  40024898 <rtems_shell_rfs_format+0x54>     <== NOT EXECUTED
40024874:	b4 10 20 01 	mov  1, %i2                                    <== NOT EXECUTED
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
    printf ("error: no driver name provided\n");                      
40024878:	10 80 00 69 	b  40024a1c <rtems_shell_rfs_format+0x1d8>     <== NOT EXECUTED
4002487c:	11 10 01 7c 	sethi  %hi(0x4005f000), %o0                    <== NOT EXECUTED
          return 1;                                                   
      }                                                               
    }                                                                 
    else                                                              
    {                                                                 
      if (!driver)                                                    
40024880:	12 80 00 55 	bne  400249d4 <rtems_shell_rfs_format+0x190>   <== NOT EXECUTED
40024884:	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++)                                    
40024888:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
4002488c:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
40024890:	04 80 00 1d 	ble  40024904 <rtems_shell_rfs_format+0xc0>    <== NOT EXECUTED
40024894:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
  {                                                                   
    if (argv[arg][0] == '-')                                          
40024898:	83 2f 60 02 	sll  %i5, 2, %g1                               <== NOT EXECUTED
4002489c:	d2 06 40 01 	ld  [ %i1 + %g1 ], %o1                         <== NOT EXECUTED
400248a0:	c2 4a 40 00 	ldsb  [ %o1 ], %g1                             <== NOT EXECUTED
400248a4:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
400248a8:	12 bf ff f6 	bne  40024880 <rtems_shell_rfs_format+0x3c>    <== NOT EXECUTED
400248ac:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
    {                                                                 
      switch (argv[arg][1])                                           
400248b0:	c2 0a 60 01 	ldub  [ %o1 + 1 ], %g1                         <== NOT EXECUTED
400248b4:	82 00 7f b7 	add  %g1, -73, %g1                             <== NOT EXECUTED
400248b8:	82 08 60 ff 	and  %g1, 0xff, %g1                            <== NOT EXECUTED
400248bc:	80 a0 60 2d 	cmp  %g1, 0x2d                                 <== NOT EXECUTED
400248c0:	08 80 00 08 	bleu  400248e0 <rtems_shell_rfs_format+0x9c>   <== NOT EXECUTED
400248c4:	84 16 e2 18 	or  %i3, 0x218, %g2                            <== NOT EXECUTED
          }                                                           
          config.inode_overhead = strtoul (argv[arg], 0, 0);          
          break;                                                      
                                                                      
        default:                                                      
          printf ("error: invalid option: %s\n", argv[arg]);          
400248c8:	11 10 01 75 	sethi  %hi(0x4005d400), %o0                    <== NOT EXECUTED
          return 1;                                                   
400248cc:	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]);          
400248d0:	40 00 71 f5 	call  400410a4 <printf>                        <== NOT EXECUTED
400248d4:	90 12 20 a8 	or  %o0, 0xa8, %o0                             <== NOT EXECUTED
400248d8:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400248dc:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
  for (arg = 1; arg < argc; arg++)                                    
  {                                                                   
    if (argv[arg][0] == '-')                                          
    {                                                                 
      switch (argv[arg][1])                                           
400248e0:	83 28 60 02 	sll  %g1, 2, %g1                               <== NOT EXECUTED
400248e4:	c2 00 80 01 	ld  [ %g2 + %g1 ], %g1                         <== NOT EXECUTED
400248e8:	81 c0 40 00 	jmp  %g1                                       <== NOT EXECUTED
400248ec:	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++)                                    
400248f0:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
400248f4:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
400248f8:	14 bf ff e8 	bg  40024898 <rtems_shell_rfs_format+0x54>     <== NOT EXECUTED
400248fc:	f4 2f bf fd 	stb  %i2, [ %fp + -3 ]                         <== NOT EXECUTED
        return 1;                                                     
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
40024900:	80 a7 20 00 	cmp  %i4, 0                                    <== NOT EXECUTED
40024904:	02 80 00 45 	be  40024a18 <rtems_shell_rfs_format+0x1d4>    <== NOT EXECUTED
40024908:	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)                         
4002490c:	90 10 00 1c 	mov  %i4, %o0                                  <== NOT EXECUTED
40024910:	40 00 3a e5 	call  400334a4 <rtems_rfs_format>              <== NOT EXECUTED
40024914:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
40024918:	80 a2 20 00 	cmp  %o0, 0                                    <== NOT EXECUTED
4002491c:	06 80 00 34 	bl  400249ec <rtems_shell_rfs_format+0x1a8>    <== NOT EXECUTED
40024920:	01 00 00 00 	nop                                            <== NOT EXECUTED
            driver, strerror (errno));                                
    return 1;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40024924:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024928:	81 e8 00 00 	restore                                        <== NOT EXECUTED
        case 'v':                                                     
          config.verbose = true;                                      
          break;                                                      
                                                                      
        case 's':                                                     
          arg++;                                                      
4002492c:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
          if (arg >= argc)                                            
40024930:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
40024934:	04 80 00 45 	ble  40024a48 <rtems_shell_rfs_format+0x204>   <== NOT EXECUTED
40024938:	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);              
4002493c:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
40024940:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40024944:	40 00 81 ad 	call  40044ff8 <strtoul>                       <== NOT EXECUTED
40024948:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
4002494c:	10 bf ff cf 	b  40024888 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
40024950:	d0 27 bf e8 	st  %o0, [ %fp + -24 ]                         <== NOT EXECUTED
        case 'I':                                                     
          config.initialise_inodes = true;                            
          break;                                                      
                                                                      
        case 'o':                                                     
          arg++;                                                      
40024954:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
          if (arg >= argc)                                            
40024958:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
4002495c:	04 80 00 47 	ble  40024a78 <rtems_shell_rfs_format+0x234>   <== NOT EXECUTED
40024960:	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);          
40024964:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
40024968:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4002496c:	40 00 81 a3 	call  40044ff8 <strtoul>                       <== NOT EXECUTED
40024970:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
40024974:	10 bf ff c5 	b  40024888 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
40024978:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         <== NOT EXECUTED
          }                                                           
          config.group_blocks = strtoul (argv[arg], 0, 0);            
          break;                                                      
                                                                      
        case 'i':                                                     
          arg++;                                                      
4002497c:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
          if (arg >= argc)                                            
40024980:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
40024984:	04 80 00 37 	ble  40024a60 <rtems_shell_rfs_format+0x21c>   <== NOT EXECUTED
40024988:	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);            
4002498c:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
40024990:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
40024994:	40 00 81 99 	call  40044ff8 <strtoul>                       <== NOT EXECUTED
40024998:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
4002499c:	10 bf ff bb 	b  40024888 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
400249a0:	d0 27 bf f0 	st  %o0, [ %fp + -16 ]                         <== NOT EXECUTED
          }                                                           
          config.block_size = strtoul (argv[arg], 0, 0);              
          break;                                                      
                                                                      
        case 'b':                                                     
          arg++;                                                      
400249a4:	ba 07 60 01 	inc  %i5                                       <== NOT EXECUTED
          if (arg >= argc)                                            
400249a8:	80 a6 00 1d 	cmp  %i0, %i5                                  <== NOT EXECUTED
400249ac:	04 80 00 21 	ble  40024a30 <rtems_shell_rfs_format+0x1ec>   <== NOT EXECUTED
400249b0:	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);            
400249b4:	d0 06 40 01 	ld  [ %i1 + %g1 ], %o0                         <== NOT EXECUTED
400249b8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
400249bc:	40 00 81 8f 	call  40044ff8 <strtoul>                       <== NOT EXECUTED
400249c0:	94 10 20 00 	clr  %o2                                       <== NOT EXECUTED
          break;                                                      
400249c4:	10 bf ff b1 	b  40024888 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
400249c8:	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;                                                      
400249cc:	10 bf ff af 	b  40024888 <rtems_shell_rfs_format+0x44>      <== NOT EXECUTED
400249d0:	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]);
400249d4:	11 10 01 7d 	sethi  %hi(0x4005f400), %o0                    <== NOT EXECUTED
        return 1;                                                     
400249d8:	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]);
400249dc:	40 00 71 b2 	call  400410a4 <printf>                        <== NOT EXECUTED
400249e0:	90 12 20 70 	or  %o0, 0x70, %o0                             <== NOT EXECUTED
400249e4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400249e8:	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));                                
400249ec:	40 00 5f 5f 	call  4003c768 <__errno>                       <== NOT EXECUTED
400249f0:	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",                       
400249f4:	40 00 7b 04 	call  40043604 <strerror>                      <== NOT EXECUTED
400249f8:	d0 02 00 00 	ld  [ %o0 ], %o0                               <== NOT EXECUTED
400249fc:	92 10 00 1c 	mov  %i4, %o1                                  <== NOT EXECUTED
40024a00:	94 10 00 08 	mov  %o0, %o2                                  <== NOT EXECUTED
40024a04:	11 10 01 7d 	sethi  %hi(0x4005f400), %o0                    <== NOT EXECUTED
40024a08:	40 00 71 a7 	call  400410a4 <printf>                        <== NOT EXECUTED
40024a0c:	90 12 20 a0 	or  %o0, 0xa0, %o0	! 4005f4a0 <rtems_rtc_shell_usage+0x18a0><== NOT EXECUTED
            driver, strerror (errno));                                
    return 1;                                                         
  }                                                                   
                                                                      
  return 0;                                                           
}                                                                     
40024a10:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024a14:	81 e8 00 00 	restore                                        <== NOT EXECUTED
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
    printf ("error: no driver name provided\n");                      
40024a18:	11 10 01 7c 	sethi  %hi(0x4005f000), %o0                    <== NOT EXECUTED
    return 1;                                                         
40024a1c:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if (!driver) {                                                      
    printf ("error: no driver name provided\n");                      
40024a20:	40 00 72 39 	call  40041304 <puts>                          <== NOT EXECUTED
40024a24:	90 12 23 90 	or  %o0, 0x390, %o0                            <== NOT EXECUTED
40024a28:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024a2c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        case 'b':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: group block count needs an argument\n");  
40024a30:	11 10 01 7c 	sethi  %hi(0x4005f000), %o0                    <== NOT EXECUTED
            return 1;                                                 
40024a34:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
                                                                      
        case 'b':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: group block count needs an argument\n");  
40024a38:	40 00 72 33 	call  40041304 <puts>                          <== NOT EXECUTED
40024a3c:	90 12 23 d8 	or  %o0, 0x3d8, %o0                            <== NOT EXECUTED
40024a40:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024a44:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        case 's':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: block size needs an argument\n");         
40024a48:	11 10 01 7c 	sethi  %hi(0x4005f000), %o0                    <== NOT EXECUTED
            return 1;                                                 
40024a4c:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
                                                                      
        case 's':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: block size needs an argument\n");         
40024a50:	40 00 72 2d 	call  40041304 <puts>                          <== NOT EXECUTED
40024a54:	90 12 23 b0 	or  %o0, 0x3b0, %o0                            <== NOT EXECUTED
40024a58:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024a5c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        case 'i':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: group inode count needs an argument\n");  
40024a60:	11 10 01 7d 	sethi  %hi(0x4005f400), %o0                    <== NOT EXECUTED
            return 1;                                                 
40024a64:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
                                                                      
        case 'i':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: group inode count needs an argument\n");  
40024a68:	40 00 72 27 	call  40041304 <puts>                          <== NOT EXECUTED
40024a6c:	90 12 20 08 	or  %o0, 8, %o0                                <== NOT EXECUTED
40024a70:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024a74:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
        case 'o':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: inode percentage overhead needs an argument\n");
40024a78:	11 10 01 7d 	sethi  %hi(0x4005f400), %o0                    <== NOT EXECUTED
            return 1;                                                 
40024a7c:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
                                                                      
        case 'o':                                                     
          arg++;                                                      
          if (arg >= argc)                                            
          {                                                           
            printf ("error: inode percentage overhead needs an argument\n");
40024a80:	40 00 72 21 	call  40041304 <puts>                          <== NOT EXECUTED
40024a84:	90 12 20 38 	or  %o0, 0x38, %o0                             <== NOT EXECUTED
40024a88:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40024a8c:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40017790 <rtems_signal_send>: rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) {
40017790:	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 )                                                  
40017794:	80 a6 60 00 	cmp  %i1, 0                                    
40017798:	12 80 00 04 	bne  400177a8 <rtems_signal_send+0x18>         
4001779c:	82 10 20 0a 	mov  0xa, %g1                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400177a0:	81 c7 e0 08 	ret                                            
400177a4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
  ASR_Information         *asr;                                       
                                                                      
  if ( !signal_set )                                                  
    return RTEMS_INVALID_NUMBER;                                      
                                                                      
  the_thread = _Thread_Get( id, &location );                          
400177a8:	90 10 00 18 	mov  %i0, %o0                                  
400177ac:	40 00 13 a5 	call  4001c640 <_Thread_Get>                   
400177b0:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
400177b4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400177b8:	80 a0 60 00 	cmp  %g1, 0                                    
400177bc:	12 80 00 20 	bne  4001783c <rtems_signal_send+0xac>         
400177c0:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];           
400177c4:	fa 02 21 4c 	ld  [ %o0 + 0x14c ], %i5                       
      asr = &api->Signal;                                             
                                                                      
      if ( ! _ASR_Is_null_handler( asr->handler ) ) {                 
400177c8:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
400177cc:	80 a0 60 00 	cmp  %g1, 0                                    
400177d0:	02 80 00 1e 	be  40017848 <rtems_signal_send+0xb8>          
400177d4:	01 00 00 00 	nop                                            
        if ( asr->is_enabled ) {                                      
400177d8:	c2 0f 60 08 	ldub  [ %i5 + 8 ], %g1                         
400177dc:	80 a0 60 00 	cmp  %g1, 0                                    
400177e0:	02 80 00 1e 	be  40017858 <rtems_signal_send+0xc8>          
400177e4:	01 00 00 00 	nop                                            
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
400177e8:	7f ff df 75 	call  4000f5bc <sparc_disable_interrupts>      
400177ec:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
400177f0:	c2 07 60 14 	ld  [ %i5 + 0x14 ], %g1                        
400177f4:	b2 10 40 19 	or  %g1, %i1, %i1                              
400177f8:	f2 27 60 14 	st  %i1, [ %i5 + 0x14 ]                        
  _ISR_Enable( _level );                                              
400177fc:	7f ff df 74 	call  4000f5cc <sparc_enable_interrupts>       
40017800:	01 00 00 00 	nop                                            
          _ASR_Post_signals( signal_set, &asr->signals_posted );      
                                                                      
          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
40017804:	03 10 00 fb 	sethi  %hi(0x4003ec00), %g1                    
40017808:	82 10 61 80 	or  %g1, 0x180, %g1	! 4003ed80 <_Per_CPU_Information>
4001780c:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
40017810:	80 a0 a0 00 	cmp  %g2, 0                                    
40017814:	02 80 00 06 	be  4001782c <rtems_signal_send+0x9c>          
40017818:	01 00 00 00 	nop                                            
4001781c:	c4 00 60 10 	ld  [ %g1 + 0x10 ], %g2                        
40017820:	80 a7 00 02 	cmp  %i4, %g2                                  
40017824:	02 80 00 15 	be  40017878 <rtems_signal_send+0xe8>          <== ALWAYS TAKEN
40017828:	84 10 20 01 	mov  1, %g2                                    
            _Thread_Dispatch_necessary = true;                        
        } else {                                                      
          _ASR_Post_signals( signal_set, &asr->signals_pending );     
        }                                                             
        _Thread_Enable_dispatch();                                    
4001782c:	40 00 13 79 	call  4001c610 <_Thread_Enable_dispatch>       
40017830:	01 00 00 00 	nop                                            
        return RTEMS_SUCCESSFUL;                                      
40017834:	10 bf ff db 	b  400177a0 <rtems_signal_send+0x10>           
40017838:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
4001783c:	82 10 20 04 	mov  4, %g1                                    
}                                                                     
40017840:	81 c7 e0 08 	ret                                            
40017844:	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();                                      
40017848:	40 00 13 72 	call  4001c610 <_Thread_Enable_dispatch>       
4001784c:	01 00 00 00 	nop                                            
      return RTEMS_NOT_DEFINED;                                       
40017850:	10 bf ff d4 	b  400177a0 <rtems_signal_send+0x10>           
40017854:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
  rtems_signal_set *signal_set                                        
)                                                                     
{                                                                     
  ISR_Level              _level;                                      
                                                                      
  _ISR_Disable( _level );                                             
40017858:	7f ff df 59 	call  4000f5bc <sparc_disable_interrupts>      
4001785c:	01 00 00 00 	nop                                            
    *signal_set |= signals;                                           
40017860:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
40017864:	b2 10 40 19 	or  %g1, %i1, %i1                              
40017868:	f2 27 60 18 	st  %i1, [ %i5 + 0x18 ]                        
  _ISR_Enable( _level );                                              
4001786c:	7f ff df 58 	call  4000f5cc <sparc_enable_interrupts>       
40017870:	01 00 00 00 	nop                                            
40017874:	30 bf ff ee 	b,a   4001782c <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;                        
40017878:	c4 28 60 0c 	stb  %g2, [ %g1 + 0xc ]                        
4001787c:	30 bf ff ec 	b,a   4001782c <rtems_signal_send+0x9c>        
                                                                      

40010110 <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 ) {
40010110:	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 )           
40010114:	92 10 00 1a 	mov  %i2, %o1                                  
40010118:	7f ff c9 1d 	call  4000258c <.umul>                         
4001011c:	90 06 60 08 	add  %i1, 8, %o0                               
                                + key_table_size + data_size;         
                                                                      
  rtems_sparse_disk *const sd = (rtems_sparse_disk *) malloc(         
40010120:	7f ff d8 6e 	call  400062d8 <malloc>                        
40010124:	90 02 20 1c 	add  %o0, 0x1c, %o0                            
40010128:	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 ) {                                        
4001012c:	80 a2 60 00 	cmp  %o1, 0                                    
40010130:	02 80 00 0b 	be  4001015c <rtems_sparse_disk_create_and_register+0x4c><== NEVER TAKEN
40010134:	90 10 20 1a 	mov  0x1a, %o0                                 
    sc = rtems_sparse_disk_register(                                  
40010138:	03 10 00 40 	sethi  %hi(0x40010000), %g1                    
4001013c:	82 10 60 18 	or  %g1, 0x18, %g1	! 40010018 <rtems_sparse_disk_free>
40010140:	90 10 00 18 	mov  %i0, %o0                                  
40010144:	c2 23 a0 5c 	st  %g1, [ %sp + 0x5c ]                        
40010148:	94 10 00 19 	mov  %i1, %o2                                  
4001014c:	96 10 00 1a 	mov  %i2, %o3                                  
40010150:	98 10 00 1b 	mov  %i3, %o4                                  
40010154:	7f ff ff b4 	call  40010024 <rtems_sparse_disk_register>    
40010158:	9a 10 00 1c 	mov  %i4, %o5                                  
  } else {                                                            
    sc = RTEMS_NO_MEMORY;                                             
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
4001015c:	81 c7 e0 08 	ret                                            
40010160:	91 e8 00 08 	restore  %g0, %o0, %o0                         
40010164:	40 01 11 e0 	call  400548e4 <__end+0x24454>                 <== NOT EXECUTED
40010168:	40 01 13 7c 	call  40054f58 <__end+0x24ac8>                 <== NOT EXECUTED
4001016c:	40 01 13 74 	call  40054f3c <__end+0x24aac>                 <== NOT EXECUTED
40010170:	40 01 13 60 	call  40054ef0 <__end+0x24a60>                 <== NOT EXECUTED
40010174:	40 01 13 60 	call  40054ef4 <__end+0x24a64>                 <== NOT EXECUTED
40010178:	40 01 13 60 	call  40054ef8 <__end+0x24a68>                 <== NOT EXECUTED
4001017c:	40 01 13 60 	call  40054efc <__end+0x24a6c>                 <== NOT EXECUTED
40010180:	40 01 13 2c 	call  40054e30 <__end+0x249a0>                 <== NOT EXECUTED
40010184:	40 01 13 18 	call  40054de4 <__end+0x24954>                 <== NOT EXECUTED
40010188:	40 01 13 18 	call  40054de8 <__end+0x24958>                 <== NOT EXECUTED
4001018c:	40 01 13 18 	call  40054dec <__end+0x2495c>                 <== NOT EXECUTED
40010190:	40 01 12 28 	call  40054a30 <__end+0x245a0>                 <== NOT EXECUTED
40010194:	40 01 12 18 	call  400549f4 <__end+0x24564>                 <== NOT EXECUTED
40010198:	40 01 12 18 	call  400549f8 <__end+0x24568>                 <== NOT EXECUTED
4001019c:	40 01 12 f4 	call  40054d6c <__end+0x248dc>                 <== NOT EXECUTED
400101a0:	40 01 12 f4 	call  40054d70 <__end+0x248e0>                 <== NOT EXECUTED
400101a4:	40 01 12 f4 	call  40054d74 <__end+0x248e4>                 <== NOT EXECUTED
400101a8:	40 01 12 f4 	call  40054d78 <__end+0x248e8>                 <== NOT EXECUTED
400101ac:	40 01 12 c0 	call  40054cac <__end+0x2481c>                 <== NOT EXECUTED
400101b0:	40 01 12 ac 	call  40054c60 <__end+0x247d0>                 <== NOT EXECUTED
400101b4:	40 01 12 ac 	call  40054c64 <__end+0x247d4>                 <== NOT EXECUTED
400101b8:	40 01 12 ac 	call  40054c68 <__end+0x247d8>                 <== NOT EXECUTED
400101bc:	40 01 28 2c 	call  4005a26c <__end+0x29ddc>                 <== NOT EXECUTED
400101c0:	40 01 28 2c 	call  4005a270 <__end+0x29de0>                 <== NOT EXECUTED
400101c4:	40 01 29 54 	call  4005a714 <__end+0x2a284>                 <== NOT EXECUTED
400101c8:	40 01 29 7c 	call  4005a7b8 <__end+0x2a328>                 <== NOT EXECUTED
400101cc:	40 01 29 7c 	call  4005a7bc <__end+0x2a32c>                 <== NOT EXECUTED
400101d0:	40 01 29 7c 	call  4005a7c0 <__end+0x2a330>                 <== NOT EXECUTED
400101d4:	40 01 28 2c 	call  4005a284 <__end+0x29df4>                 <== NOT EXECUTED
400101d8:	40 01 29 44 	call  4005a6e8 <__end+0x2a258>                 <== NOT EXECUTED
400101dc:	40 01 29 3c 	call  4005a6cc <__end+0x2a23c>                 <== NOT EXECUTED
400101e0:	40 01 29 84 	call  4005a7f0 <__end+0x2a360>                 <== NOT EXECUTED
400101e4:	40 01 28 2c 	call  4005a294 <__end+0x29e04>                 <== NOT EXECUTED
                                                                      

40010024 <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 ) {
40010024:	9d e3 bf a0 	save  %sp, -96, %sp                            
40010028:	a2 10 00 18 	mov  %i0, %l1                                  
4001002c:	a0 10 00 19 	mov  %i1, %l0                                  
        sparse_disk_ioctl,                                            
        sparse_disk                                                   
      );                                                              
    }                                                                 
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
40010030:	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 ) {                    
40010034:	80 a6 c0 1c 	cmp  %i3, %i4                                  
40010038:	08 80 00 04 	bleu  40010048 <rtems_sparse_disk_register+0x24><== ALWAYS TAKEN
4001003c:	f2 07 a0 5c 	ld  [ %fp + 0x5c ], %i1                        
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
40010040:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40010044:	81 e8 00 00 	restore                                        <== NOT EXECUTED
  const uint8_t                                                     fill_pattern )
{                                                                     
  rtems_status_code sc;                                               
  rtems_blkdev_bnum i;                                                
                                                                      
  if ( NULL == sd )                                                   
40010048:	80 a4 20 00 	cmp  %l0, 0                                    
4001004c:	02 80 00 2f 	be  40010108 <rtems_sparse_disk_register+0xe4> <== NEVER TAKEN
40010050:	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                    
40010054:	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 );    
40010058:	90 10 00 10 	mov  %l0, %o0                                  
4001005c:	b0 04 a0 1c 	add  %l2, 0x1c, %i0                            
40010060:	40 00 38 2e 	call  4001e118 <memset>                        
40010064:	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;
40010068:	92 10 00 1a 	mov  %i2, %o1                                  
                                                                      
  memset( data, 0, sizeof( rtems_sparse_disk ) + key_table_size );    
                                                                      
  sd->fill_pattern = fill_pattern;                                    
4001006c:	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;
40010070:	7f ff c9 47 	call  4000258c <.umul>                         
40010074:	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 ),
40010078:	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;
4001007c:	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 ),
40010080:	92 10 00 1d 	mov  %i5, %o1                                  
40010084:	40 00 38 25 	call  4001e118 <memset>                        
40010088:	90 10 00 18 	mov  %i0, %o0                                  
          sd->fill_pattern,                                           
          data_size );                                                
                                                                      
  sd->delete_handler = sparse_disk_delete;                            
                                                                      
  sc                 = rtems_semaphore_create(                        
4001008c:	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;                            
40010090:	f2 24 20 10 	st  %i1, [ %l0 + 0x10 ]                        
                                                                      
  sc                 = rtems_semaphore_create(                        
40010094:	94 10 20 54 	mov  0x54, %o2                                 
40010098:	11 14 d4 10 	sethi  %hi(0x53504000), %o0                    
4001009c:	96 10 20 00 	clr  %o3                                       
400100a0:	90 12 21 52 	or  %o0, 0x152, %o0                            
400100a4:	7f ff e8 ad 	call  4000a358 <rtems_semaphore_create>        
400100a8:	98 10 00 10 	mov  %l0, %o4                                  
    RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY, 
    0,                                                                
    &sd->mutex                                                        
    );                                                                
                                                                      
  if ( sc != RTEMS_SUCCESSFUL ) {                                     
400100ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400100b0:	12 bf ff e4 	bne  40010040 <rtems_sparse_disk_register+0x1c><== NEVER TAKEN
400100b4:	84 04 20 1c 	add  %l0, 0x1c, %g2                            
    return sc;                                                        
  }                                                                   
                                                                      
  data                  += sizeof( rtems_sparse_disk );               
                                                                      
  sd->blocks_with_buffer = blocks_with_buffer;                        
400100b8:	f6 24 20 04 	st  %i3, [ %l0 + 4 ]                           
  sd->key_table          = (rtems_sparse_disk_key *) data;            
400100bc:	c4 24 20 18 	st  %g2, [ %l0 + 0x18 ]                        
                                                                      
  data                  += key_table_size;                            
                                                                      
  for ( i = 0; i < blocks_with_buffer; ++i, data += media_block_size ) {
400100c0:	82 10 20 00 	clr  %g1                                       
400100c4:	80 a6 e0 00 	cmp  %i3, 0                                    
400100c8:	02 80 00 08 	be  400100e8 <rtems_sparse_disk_register+0xc4> <== NEVER TAKEN
400100cc:	84 00 80 12 	add  %g2, %l2, %g2                             
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
                                                                      
rtems_status_code rtems_sparse_disk_register(                         
400100d0:	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;                                     
400100d4:	c4 20 e0 20 	st  %g2, [ %g3 + 0x20 ]                        
400100d8:	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 ) {
400100dc:	80 a4 80 01 	cmp  %l2, %g1                                  
400100e0:	12 bf ff fc 	bne  400100d0 <rtems_sparse_disk_register+0xac>
400100e4:	84 00 80 1a 	add  %g2, %i2, %g2                             
    sd->key_table[i].data = data;                                     
  }                                                                   
                                                                      
  sd->media_block_size = media_block_size;                            
400100e8:	f4 24 20 0c 	st  %i2, [ %l0 + 0xc ]                         
      sparse_disk_delete,                                             
      fill_pattern                                                    
    );                                                                
                                                                      
    if ( RTEMS_SUCCESSFUL == sc ) {                                   
      sc = rtems_blkdev_create(                                       
400100ec:	b2 10 00 1a 	mov  %i2, %i1                                  
400100f0:	37 10 00 3f 	sethi  %hi(0x4000fc00), %i3                    
400100f4:	b4 10 00 1c 	mov  %i4, %i2                                  
400100f8:	b0 10 00 11 	mov  %l1, %i0                                  
400100fc:	b6 16 e1 40 	or  %i3, 0x140, %i3                            
40010100:	40 00 0b 63 	call  40012e8c <rtems_blkdev_create>           
40010104:	99 e8 00 10 	restore  %g0, %l0, %o4                         
  } else {                                                            
    sc = RTEMS_INVALID_NUMBER;                                        
  }                                                                   
                                                                      
  return sc;                                                          
}                                                                     
40010108:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001010c:	91 e8 20 09 	restore  %g0, 9, %o0                           <== NOT EXECUTED
                                                                      

40026450 <rtems_stack_checker_begin_extension>: Thread_Control *the_thread ) { Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */
40026450:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
40026454:	80 a0 60 00 	cmp  %g1, 0                                    
40026458:	02 80 00 0c 	be  40026488 <rtems_stack_checker_begin_extension+0x38><== NEVER TAKEN
4002645c:	05 10 01 a8 	sethi  %hi(0x4006a000), %g2                    
    return;                                                           
                                                                      
  the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
                                                                      
  *the_pattern = Stack_check_Pattern;                                 
40026460:	c2 02 20 b8 	ld  [ %o0 + 0xb8 ], %g1                        
40026464:	c6 00 a2 cc 	ld  [ %g2 + 0x2cc ], %g3                       
40026468:	84 10 a2 cc 	or  %g2, 0x2cc, %g2                            
4002646c:	c6 20 60 08 	st  %g3, [ %g1 + 8 ]                           
40026470:	c6 00 a0 04 	ld  [ %g2 + 4 ], %g3                           
40026474:	c6 20 60 0c 	st  %g3, [ %g1 + 0xc ]                         
40026478:	c6 00 a0 08 	ld  [ %g2 + 8 ], %g3                           
4002647c:	c6 20 60 10 	st  %g3, [ %g1 + 0x10 ]                        
40026480:	c4 00 a0 0c 	ld  [ %g2 + 0xc ], %g2                         
40026484:	c4 20 60 14 	st  %g2, [ %g1 + 0x14 ]                        
40026488:	81 c3 e0 08 	retl                                           
                                                                      

4002639c <rtems_stack_checker_create_extension>: */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) {
4002639c:	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 )                                      
400263a0:	3b 10 01 a3 	sethi  %hi(0x40068c00), %i5                    
400263a4:	c2 07 63 80 	ld  [ %i5 + 0x380 ], %g1	! 40068f80 <Stack_check_Initialized>
400263a8:	80 a0 60 00 	cmp  %g1, 0                                    
400263ac:	12 80 00 20 	bne  4002642c <rtems_stack_checker_create_extension+0x90>
400263b0:	07 10 01 a8 	sethi  %hi(0x4006a000), %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 ];                                          
400263b4:	09 3f bb 7c 	sethi  %hi(0xfeedf000), %g4                    
400263b8:	82 10 e2 cc 	or  %g3, 0x2cc, %g1                            
400263bc:	88 11 20 0d 	or  %g4, 0xd, %g4                              
400263c0:	c8 20 e2 cc 	st  %g4, [ %g3 + 0x2cc ]                       
400263c4:	07 02 eb 43 	sethi  %hi(0xbad0c00), %g3                     
400263c8:	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) {      
400263cc:	05 10 01 a7 	sethi  %hi(0x40069c00), %g2                    
400263d0:	d0 00 a1 a0 	ld  [ %g2 + 0x1a0 ], %o0	! 40069da0 <_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 ];                                          
400263d4:	c6 20 60 04 	st  %g3, [ %g1 + 4 ]                           
400263d8:	07 37 ab 7c 	sethi  %hi(0xdeadf000), %g3                    
400263dc:	86 10 e0 0d 	or  %g3, 0xd, %g3	! deadf00d <LEON_REG+0x5eadf00d>
400263e0:	c6 20 60 08 	st  %g3, [ %g1 + 8 ]                           
400263e4:	07 18 03 43 	sethi  %hi(0x600d0c00), %g3                    
400263e8:	86 10 e1 06 	or  %g3, 0x106, %g3	! 600d0d06 <RAM_END+0x1fcd0d06>
400263ec:	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) {      
400263f0:	80 a2 20 00 	cmp  %o0, 0                                    
400263f4:	02 80 00 0c 	be  40026424 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
400263f8:	84 10 a1 a0 	or  %g2, 0x1a0, %g2                            
400263fc:	d4 00 a0 04 	ld  [ %g2 + 4 ], %o2                           
40026400:	80 a2 a0 00 	cmp  %o2, 0                                    
40026404:	02 80 00 08 	be  40026424 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
40026408:	03 10 01 a8 	sethi  %hi(0x4006a000), %g1                    
      Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;    
4002640c:	84 10 62 dc 	or  %g1, 0x2dc, %g2	! 4006a2dc <Stack_check_Interrupt_stack>
      Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40026410:	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;    
40026414:	d0 20 a0 04 	st  %o0, [ %g2 + 4 ]                           
      Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
40026418:	d4 20 62 dc 	st  %o2, [ %g1 + 0x2dc ]                       
                                  (char *) _CPU_Interrupt_stack_low;  
      Stack_check_Dope_stack(&Stack_check_Interrupt_stack);           
4002641c:	40 00 66 b1 	call  4003fee0 <memset>                        
40026420:	92 10 20 a5 	mov  0xa5, %o1                                 
   }                                                                  
  #endif                                                              
                                                                      
  Stack_check_Initialized = 1;                                        
40026424:	82 10 20 01 	mov  1, %g1                                    
40026428:	c2 27 63 80 	st  %g1, [ %i5 + 0x380 ]                       
  Thread_Control *the_thread                                          
)                                                                     
{                                                                     
  Stack_check_Initialize();                                           
                                                                      
  if (the_thread)                                                     
4002642c:	80 a6 60 00 	cmp  %i1, 0                                    
40026430:	02 80 00 06 	be  40026448 <rtems_stack_checker_create_extension+0xac><== NEVER TAKEN
40026434:	01 00 00 00 	nop                                            
    Stack_check_Dope_stack(&the_thread->Start.Initial_stack);         
40026438:	d0 06 60 b8 	ld  [ %i1 + 0xb8 ], %o0                        
4002643c:	d4 06 60 b4 	ld  [ %i1 + 0xb4 ], %o2                        
40026440:	40 00 66 a8 	call  4003fee0 <memset>                        
40026444:	92 10 20 a5 	mov  0xa5, %o1                                 
                                                                      
  return true;                                                        
}                                                                     
40026448:	81 c7 e0 08 	ret                                            
4002644c:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      

400265b0 <rtems_stack_checker_is_blown>: /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) {
400265b0:	9d e3 bf a0 	save  %sp, -96, %sp                            
  Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 
400265b4:	39 10 01 a7 	sethi  %hi(0x40069c00), %i4                    
400265b8:	b8 17 21 a0 	or  %i4, 0x1a0, %i4	! 40069da0 <_Per_CPU_Information>
400265bc:	c2 07 20 10 	ld  [ %i4 + 0x10 ], %g1                        
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
400265c0:	d0 00 60 b8 	ld  [ %g1 + 0xb8 ], %o0                        
400265c4:	80 a7 80 08 	cmp  %fp, %o0                                  
400265c8:	0a 80 00 06 	bcs  400265e0 <rtems_stack_checker_is_blown+0x30><== NEVER TAKEN
400265cc:	ba 10 20 01 	mov  1, %i5                                    
      return false;                                                   
    }                                                                 
    if ( sp > (the_stack->area + the_stack->size) ) {                 
400265d0:	c2 00 60 b4 	ld  [ %g1 + 0xb4 ], %g1                        
400265d4:	82 02 00 01 	add  %o0, %g1, %g1                             
400265d8:	80 a0 40 1e 	cmp  %g1, %fp                                  
400265dc:	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 ) {                                    
400265e0:	03 10 01 a3 	sethi  %hi(0x40068c00), %g1                    
400265e4:	c2 00 63 80 	ld  [ %g1 + 0x380 ], %g1	! 40068f80 <Stack_check_Initialized>
400265e8:	80 a0 60 00 	cmp  %g1, 0                                    
400265ec:	02 80 00 12 	be  40026634 <rtems_stack_checker_is_blown+0x84><== NEVER TAKEN
400265f0:	82 10 20 00 	clr  %g1                                       
    pattern_ok = (!memcmp(                                            
400265f4:	90 02 20 08 	add  %o0, 8, %o0                               
400265f8:	94 10 20 10 	mov  0x10, %o2                                 
400265fc:	13 10 01 a8 	sethi  %hi(0x4006a000), %o1                    
40026600:	40 00 65 7f 	call  4003fbfc <memcmp>                        
40026604:	92 12 62 cc 	or  %o1, 0x2cc, %o1	! 4006a2cc <Stack_check_Pattern>
40026608:	80 a0 00 08 	cmp  %g0, %o0                                  
4002660c:	82 60 3f ff 	subx  %g0, -1, %g1                             
40026610:	92 10 00 01 	mov  %g1, %o1                                  
40026614:	82 18 60 01 	xor  %g1, 1, %g1                               
                                                                      
                                                                      
  /*                                                                  
   * Let's report as much as we can.                                  
   */                                                                 
  if ( !sp_ok || !pattern_ok ) {                                      
40026618:	80 88 60 ff 	btst  0xff, %g1                                
4002661c:	12 80 00 08 	bne  4002663c <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
40026620:	80 8f 60 ff 	btst  0xff, %i5                                
40026624:	12 80 00 06 	bne  4002663c <rtems_stack_checker_is_blown+0x8c><== NEVER TAKEN
40026628:	b0 10 20 00 	clr  %i0                                       
                                                                      
  /*                                                                  
   * The Stack Pointer and the Pattern Area are OK so return false.   
   */                                                                 
  return false;                                                       
}                                                                     
4002662c:	81 c7 e0 08 	ret                                            
40026630:	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;                                   
40026634:	10 bf ff f9 	b  40026618 <rtems_stack_checker_is_blown+0x68><== NOT EXECUTED
40026638:	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 );   
4002663c:	d0 07 20 10 	ld  [ %i4 + 0x10 ], %o0                        <== NOT EXECUTED
40026640:	7f ff ff 94 	call  40026490 <Stack_check_report_blown_task> <== NOT EXECUTED
40026644:	92 0a 60 01 	and  %o1, 1, %o1                               <== NOT EXECUTED
                                                                      

400266ac <rtems_stack_checker_report_usage>: } void rtems_stack_checker_report_usage( void ) { rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
400266ac:	13 10 00 a3 	sethi  %hi(0x40028c00), %o1                    <== NOT EXECUTED
400266b0:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
400266b4:	92 12 61 44 	or  %o1, 0x144, %o1                            <== NOT EXECUTED
400266b8:	82 13 c0 00 	mov  %o7, %g1                                  <== NOT EXECUTED
400266bc:	7f ff ff e4 	call  4002664c <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
400266c0:	9e 10 40 00 	mov  %g1, %o7                                  <== NOT EXECUTED
                                                                      

4002664c <rtems_stack_checker_report_usage_with_plugin>: void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) {
4002664c:	9d e3 bf a0 	save  %sp, -96, %sp                            <== NOT EXECUTED
  if ( !print )                                                       
40026650:	80 a6 60 00 	cmp  %i1, 0                                    <== NOT EXECUTED
40026654:	02 80 00 14 	be  400266a4 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED
40026658:	39 10 01 a3 	sethi  %hi(0x40068c00), %i4                    <== NOT EXECUTED
    return;                                                           
                                                                      
  print_context = context;                                            
  print_handler = print;                                              
4002665c:	3b 10 01 a3 	sethi  %hi(0x40068c00), %i5                    <== NOT EXECUTED
)                                                                     
{                                                                     
  if ( !print )                                                       
    return;                                                           
                                                                      
  print_context = context;                                            
40026660:	f0 27 23 84 	st  %i0, [ %i4 + 0x384 ]                       <== NOT EXECUTED
  print_handler = print;                                              
40026664:	f2 27 63 88 	st  %i1, [ %i5 + 0x388 ]                       <== NOT EXECUTED
                                                                      
  (*print)( context, "Stack usage by thread\n");                      
40026668:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4002666c:	13 10 01 7f 	sethi  %hi(0x4005fc00), %o1                    <== NOT EXECUTED
40026670:	9f c6 40 00 	call  %i1                                      <== NOT EXECUTED
40026674:	92 12 62 20 	or  %o1, 0x220, %o1	! 4005fe20 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8><== NOT EXECUTED
  (*print)( context,                                                  
40026678:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4002667c:	13 10 01 7f 	sethi  %hi(0x4005fc00), %o1                    <== NOT EXECUTED
40026680:	9f c6 40 00 	call  %i1                                      <== NOT EXECUTED
40026684:	92 12 62 38 	or  %o1, 0x238, %o1	! 4005fe38 <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 );   
40026688:	11 10 00 98 	sethi  %hi(0x40026000), %o0                    <== NOT EXECUTED
4002668c:	40 00 12 83 	call  4002b098 <rtems_iterate_over_all_threads><== NOT EXECUTED
40026690:	90 12 22 1c 	or  %o0, 0x21c, %o0	! 4002621c <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);            
40026694:	7f ff fe e2 	call  4002621c <Stack_check_Dump_threads_usage><== NOT EXECUTED
40026698:	90 10 3f ff 	mov  -1, %o0                                   <== NOT EXECUTED
  #endif                                                              
                                                                      
  print_context = NULL;                                               
4002669c:	c0 27 23 84 	clr  [ %i4 + 0x384 ]                           <== NOT EXECUTED
  print_handler = NULL;                                               
400266a0:	c0 27 63 88 	clr  [ %i5 + 0x388 ]                           <== NOT EXECUTED
400266a4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
400266a8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40026540 <rtems_stack_checker_switch_extension>: */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) {
40026540:	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);                  
40026544:	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,                                     
40026548:	13 10 01 a8 	sethi  %hi(0x4006a000), %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);                  
4002654c:	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,                                     
40026550:	94 10 20 10 	mov  0x10, %o2                                 
)                                                                     
{                                                                     
  #if defined(__GNUC__)                                               
    void *sp = __builtin_frame_address(0);                            
                                                                      
    if ( sp < the_stack->area ) {                                     
40026554:	80 a7 80 01 	cmp  %fp, %g1                                  
40026558:	0a 80 00 07 	bcs  40026574 <rtems_stack_checker_switch_extension+0x34><== NEVER TAKEN
4002655c:	92 12 62 cc 	or  %o1, 0x2cc, %o1                            
      return false;                                                   
    }                                                                 
    if ( sp > (the_stack->area + the_stack->size) ) {                 
40026560:	c4 06 20 b4 	ld  [ %i0 + 0xb4 ], %g2                        
40026564:	82 00 40 02 	add  %g1, %g2, %g1                             
40026568:	80 a7 80 01 	cmp  %fp, %g1                                  
4002656c:	08 80 00 0a 	bleu  40026594 <rtems_stack_checker_switch_extension+0x54><== ALWAYS TAKEN
40026570:	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,                                     
40026574:	40 00 65 a2 	call  4003fbfc <memcmp>                        <== NOT EXECUTED
40026578:	01 00 00 00 	nop                                            <== NOT EXECUTED
4002657c:	80 a0 00 08 	cmp  %g0, %o0                                  <== NOT EXECUTED
40026580:	82 60 3f ff 	subx  %g0, -1, %g1                             <== NOT EXECUTED
40026584:	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 );             
40026588:	90 10 00 18 	mov  %i0, %o0                                  <== NOT EXECUTED
4002658c:	7f ff ff c1 	call  40026490 <Stack_check_report_blown_task> <== NOT EXECUTED
40026590:	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,                                     
40026594:	40 00 65 9a 	call  4003fbfc <memcmp>                        
40026598:	01 00 00 00 	nop                                            
            (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
                                                                      
  if ( !sp_ok || !pattern_ok ) {                                      
4002659c:	80 a2 20 00 	cmp  %o0, 0                                    
400265a0:	12 bf ff fa 	bne  40026588 <rtems_stack_checker_switch_extension+0x48><== NEVER TAKEN
400265a4:	92 10 20 00 	clr  %o1                                       
400265a8:	81 c7 e0 08 	ret                                            
400265ac:	81 e8 00 00 	restore                                        
                                                                      

4000ef44 <rtems_string_to_double>: rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) {
4000ef44:	9d e3 bf 98 	save  %sp, -104, %sp                           
  double result;                                                      
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000ef48:	80 a6 60 00 	cmp  %i1, 0                                    
4000ef4c:	02 80 00 1b 	be  4000efb8 <rtems_string_to_double+0x74>     
4000ef50:	b6 10 20 09 	mov  9, %i3                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000ef54:	40 00 0c 00 	call  40011f54 <__errno>                       
4000ef58:	01 00 00 00 	nop                                            
4000ef5c:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000ef60:	c0 26 40 00 	clr  [ %i1 ]                                   
4000ef64:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
                                                                      
  result = strtod( s, &end );                                         
4000ef68:	90 10 00 18 	mov  %i0, %o0                                  
4000ef6c:	40 00 17 5b 	call  40014cd8 <strtod>                        
4000ef70:	92 07 bf fc 	add  %fp, -4, %o1                              
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000ef74:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtod( s, &end );                                         
4000ef78:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
  if ( endptr )                                                       
4000ef7c:	80 a6 a0 00 	cmp  %i2, 0                                    
4000ef80:	02 80 00 03 	be  4000ef8c <rtems_string_to_double+0x48>     
4000ef84:	ba 10 00 09 	mov  %o1, %i5                                  
    *endptr = end;                                                    
4000ef88:	c2 26 80 00 	st  %g1, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000ef8c:	80 a6 00 01 	cmp  %i0, %g1                                  
4000ef90:	02 80 00 0a 	be  4000efb8 <rtems_string_to_double+0x74>     
4000ef94:	b6 10 20 0b 	mov  0xb, %i3                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000ef98:	40 00 0b ef 	call  40011f54 <__errno>                       
4000ef9c:	01 00 00 00 	nop                                            
4000efa0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000efa4:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000efa8:	02 80 00 06 	be  4000efc0 <rtems_string_to_double+0x7c>     
4000efac:	90 10 00 1c 	mov  %i4, %o0                                  
    (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000efb0:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000efb4:	b6 10 20 00 	clr  %i3                                       
}                                                                     
4000efb8:	81 c7 e0 08 	ret                                            
4000efbc:	91 e8 00 1b 	restore  %g0, %i3, %o0                         
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000efc0:	92 10 00 1d 	mov  %i5, %o1                                  
4000efc4:	94 10 20 00 	clr  %o2                                       
4000efc8:	96 10 20 00 	clr  %o3                                       
4000efcc:	40 00 41 ce 	call  4001f704 <__eqdf2>                       
4000efd0:	b6 10 20 0a 	mov  0xa, %i3                                  
4000efd4:	80 a2 20 00 	cmp  %o0, 0                                    
4000efd8:	02 bf ff f8 	be  4000efb8 <rtems_string_to_double+0x74>     <== NEVER TAKEN
4000efdc:	90 10 00 1c 	mov  %i4, %o0                                  
    (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
4000efe0:	92 10 00 1d 	mov  %i5, %o1                                  
4000efe4:	15 1f fb ff 	sethi  %hi(0x7feffc00), %o2                    
4000efe8:	96 10 3f ff 	mov  -1, %o3                                   
4000efec:	40 00 41 dc 	call  4001f75c <__gtdf2>                       
4000eff0:	94 12 a3 ff 	or  %o2, 0x3ff, %o2                            
4000eff4:	80 a2 20 00 	cmp  %o0, 0                                    
4000eff8:	14 bf ff f0 	bg  4000efb8 <rtems_string_to_double+0x74>     
4000effc:	90 10 00 1c 	mov  %i4, %o0                                  
4000f000:	92 10 00 1d 	mov  %i5, %o1                                  
4000f004:	15 3f fb ff 	sethi  %hi(0xffeffc00), %o2                    
4000f008:	96 10 3f ff 	mov  -1, %o3                                   
4000f00c:	40 00 42 00 	call  4001f80c <__ltdf2>                       
4000f010:	94 12 a3 ff 	or  %o2, 0x3ff, %o2                            
4000f014:	80 a2 20 00 	cmp  %o0, 0                                    
4000f018:	06 bf ff e8 	bl  4000efb8 <rtems_string_to_double+0x74>     <== ALWAYS TAKEN
4000f01c:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000f020:	10 bf ff e5 	b  4000efb4 <rtems_string_to_double+0x70>      <== NOT EXECUTED
4000f024:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
                                                                      

4000f028 <rtems_string_to_float>: rtems_status_code rtems_string_to_float ( const char *s, float *n, char **endptr ) {
4000f028:	9d e3 bf 98 	save  %sp, -104, %sp                           
  float result;                                                       
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000f02c:	80 a6 60 00 	cmp  %i1, 0                                    
4000f030:	02 80 00 19 	be  4000f094 <rtems_string_to_float+0x6c>      
4000f034:	ba 10 20 09 	mov  9, %i5                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000f038:	40 00 0b c7 	call  40011f54 <__errno>                       
4000f03c:	01 00 00 00 	nop                                            
4000f040:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000f044:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtof( s, &end );                                         
4000f048:	90 10 00 18 	mov  %i0, %o0                                  
4000f04c:	40 00 17 2a 	call  40014cf4 <strtof>                        
4000f050:	92 07 bf fc 	add  %fp, -4, %o1                              
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000f054:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtof( s, &end );                                         
                                                                      
  if ( endptr )                                                       
4000f058:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f05c:	02 80 00 03 	be  4000f068 <rtems_string_to_float+0x40>      
4000f060:	b8 10 00 08 	mov  %o0, %i4                                  
    *endptr = end;                                                    
4000f064:	c2 26 80 00 	st  %g1, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000f068:	80 a6 00 01 	cmp  %i0, %g1                                  
4000f06c:	02 80 00 0a 	be  4000f094 <rtems_string_to_float+0x6c>      
4000f070:	ba 10 20 0b 	mov  0xb, %i5                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f074:	40 00 0b b8 	call  40011f54 <__errno>                       
4000f078:	01 00 00 00 	nop                                            
4000f07c:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000f080:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000f084:	02 80 00 06 	be  4000f09c <rtems_string_to_float+0x74>      
4000f088:	90 10 00 1c 	mov  %i4, %o0                                  
    (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000f08c:	f8 26 40 00 	st  %i4, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000f090:	ba 10 20 00 	clr  %i5                                       
}                                                                     
4000f094:	81 c7 e0 08 	ret                                            
4000f098:	91 e8 00 1d 	restore  %g0, %i5, %o0                         
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f09c:	92 10 20 00 	clr  %o1                                       
4000f0a0:	40 00 3e f4 	call  4001ec70 <__eqsf2>                       
4000f0a4:	ba 10 20 0a 	mov  0xa, %i5                                  
4000f0a8:	80 a2 20 00 	cmp  %o0, 0                                    
4000f0ac:	02 bf ff fa 	be  4000f094 <rtems_string_to_float+0x6c>      <== NEVER TAKEN
4000f0b0:	90 10 00 1c 	mov  %i4, %o0                                  
    (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
4000f0b4:	13 1f df ff 	sethi  %hi(0x7f7ffc00), %o1                    
4000f0b8:	40 00 3f 03 	call  4001ecc4 <__gtsf2>                       
4000f0bc:	92 12 63 ff 	or  %o1, 0x3ff, %o1	! 7f7fffff <RAM_END+0x3f3fffff>
4000f0c0:	80 a2 20 00 	cmp  %o0, 0                                    
4000f0c4:	14 bf ff f4 	bg  4000f094 <rtems_string_to_float+0x6c>      
4000f0c8:	90 10 00 1c 	mov  %i4, %o0                                  
4000f0cc:	13 3f df ff 	sethi  %hi(0xff7ffc00), %o1                    
4000f0d0:	40 00 3f 12 	call  4001ed18 <__ltsf2>                       
4000f0d4:	92 12 63 ff 	or  %o1, 0x3ff, %o1	! ff7fffff <LEON_REG+0x7f7fffff>
4000f0d8:	80 a2 20 00 	cmp  %o0, 0                                    
4000f0dc:	06 bf ff ee 	bl  4000f094 <rtems_string_to_float+0x6c>      <== ALWAYS TAKEN
4000f0e0:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000f0e4:	10 bf ff eb 	b  4000f090 <rtems_string_to_float+0x68>       <== NOT EXECUTED
4000f0e8:	f8 26 40 00 	st  %i4, [ %i1 ]                               <== NOT EXECUTED
                                                                      

40020758 <rtems_string_to_int>: const char *s, int *n, char **endptr, int base ) {
40020758:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4002075c:	80 a6 60 00 	cmp  %i1, 0                                    
40020760:	02 80 00 1a 	be  400207c8 <rtems_string_to_int+0x70>        
40020764:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
40020768:	40 00 70 00 	call  4003c768 <__errno>                       
4002076c:	01 00 00 00 	nop                                            
40020770:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
40020774:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtol( s, &end, base );                                   
40020778:	90 10 00 18 	mov  %i0, %o0                                  
4002077c:	92 07 bf fc 	add  %fp, -4, %o1                              
40020780:	40 00 90 d0 	call  40044ac0 <strtol>                        
40020784:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
40020788:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
                                                                      
  if ( endptr )                                                       
4002078c:	80 a6 a0 00 	cmp  %i2, 0                                    
40020790:	02 80 00 03 	be  4002079c <rtems_string_to_int+0x44>        
40020794:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
40020798:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4002079c:	80 a6 00 02 	cmp  %i0, %g2                                  
400207a0:	02 80 00 0a 	be  400207c8 <rtems_string_to_int+0x70>        
400207a4:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
400207a8:	40 00 6f f0 	call  4003c768 <__errno>                       
400207ac:	01 00 00 00 	nop                                            
400207b0:	c2 02 00 00 	ld  [ %o0 ], %g1                               
400207b4:	80 a0 60 22 	cmp  %g1, 0x22                                 
400207b8:	02 80 00 06 	be  400207d0 <rtems_string_to_int+0x78>        
400207bc:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
400207c0:	fa 26 40 00 	st  %i5, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
400207c4:	82 10 20 00 	clr  %g1                                       
}                                                                     
400207c8:	81 c7 e0 08 	ret                                            
400207cc:	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 )))
400207d0:	82 38 40 1d 	xnor  %g1, %i5, %g1                            
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
400207d4:	80 a0 60 00 	cmp  %g1, 0                                    
400207d8:	02 bf ff fc 	be  400207c8 <rtems_string_to_int+0x70>        
400207dc:	82 10 20 0a 	mov  0xa, %g1                                  
400207e0:	80 a7 60 00 	cmp  %i5, 0                                    
400207e4:	02 bf ff f9 	be  400207c8 <rtems_string_to_int+0x70>        <== NEVER TAKEN
400207e8:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
400207ec:	80 a7 40 02 	cmp  %i5, %g2                                  
400207f0:	02 bf ff f6 	be  400207c8 <rtems_string_to_int+0x70>        <== ALWAYS TAKEN
400207f4:	01 00 00 00 	nop                                            
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
400207f8:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
400207fc:	10 bf ff f3 	b  400207c8 <rtems_string_to_int+0x70>         <== NOT EXECUTED
40020800:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

4000f270 <rtems_string_to_long>: const char *s, long *n, char **endptr, int base ) {
4000f270:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long result;                                                        
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000f274:	80 a6 60 00 	cmp  %i1, 0                                    
4000f278:	02 80 00 1a 	be  4000f2e0 <rtems_string_to_long+0x70>       
4000f27c:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000f280:	40 00 0b 35 	call  40011f54 <__errno>                       
4000f284:	01 00 00 00 	nop                                            
4000f288:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000f28c:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtol( s, &end, base );                                   
4000f290:	90 10 00 18 	mov  %i0, %o0                                  
4000f294:	92 07 bf fc 	add  %fp, -4, %o1                              
4000f298:	40 00 17 38 	call  40014f78 <strtol>                        
4000f29c:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000f2a0:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtol( s, &end, base );                                   
                                                                      
  if ( endptr )                                                       
4000f2a4:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f2a8:	02 80 00 03 	be  4000f2b4 <rtems_string_to_long+0x44>       
4000f2ac:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
4000f2b0:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000f2b4:	80 a6 00 02 	cmp  %i0, %g2                                  
4000f2b8:	02 80 00 0a 	be  4000f2e0 <rtems_string_to_long+0x70>       
4000f2bc:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f2c0:	40 00 0b 25 	call  40011f54 <__errno>                       
4000f2c4:	01 00 00 00 	nop                                            
4000f2c8:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000f2cc:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000f2d0:	02 80 00 06 	be  4000f2e8 <rtems_string_to_long+0x78>       
4000f2d4:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000f2d8:	fa 26 40 00 	st  %i5, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000f2dc:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000f2e0:	81 c7 e0 08 	ret                                            
4000f2e4:	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 )))
4000f2e8:	82 38 40 1d 	xnor  %g1, %i5, %g1                            
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f2ec:	80 a0 60 00 	cmp  %g1, 0                                    
4000f2f0:	02 bf ff fc 	be  4000f2e0 <rtems_string_to_long+0x70>       
4000f2f4:	82 10 20 0a 	mov  0xa, %g1                                  
4000f2f8:	80 a7 60 00 	cmp  %i5, 0                                    
4000f2fc:	02 bf ff f9 	be  4000f2e0 <rtems_string_to_long+0x70>       <== NEVER TAKEN
4000f300:	05 20 00 00 	sethi  %hi(0x80000000), %g2                    
    (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
4000f304:	80 a7 40 02 	cmp  %i5, %g2                                  
4000f308:	02 bf ff f6 	be  4000f2e0 <rtems_string_to_long+0x70>       <== ALWAYS TAKEN
4000f30c:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000f310:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000f314:	10 bf ff f3 	b  4000f2e0 <rtems_string_to_long+0x70>        <== NOT EXECUTED
4000f318:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

4000f198 <rtems_string_to_long_long>: const char *s, long long *n, char **endptr, int base ) {
4000f198:	9d e3 bf 98 	save  %sp, -104, %sp                           
  long long result;                                                   
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000f19c:	80 a6 60 00 	cmp  %i1, 0                                    
4000f1a0:	02 80 00 1c 	be  4000f210 <rtems_string_to_long_long+0x78>  
4000f1a4:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000f1a8:	40 00 0b 6b 	call  40011f54 <__errno>                       
4000f1ac:	01 00 00 00 	nop                                            
4000f1b0:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000f1b4:	c0 26 40 00 	clr  [ %i1 ]                                   
4000f1b8:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
                                                                      
  result = strtoll( s, &end, base );                                  
4000f1bc:	90 10 00 18 	mov  %i0, %o0                                  
4000f1c0:	92 07 bf fc 	add  %fp, -4, %o1                              
4000f1c4:	40 00 17 76 	call  40014f9c <strtoll>                       
4000f1c8:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000f1cc:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoll( s, &end, base );                                  
4000f1d0:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
  if ( endptr )                                                       
4000f1d4:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f1d8:	02 80 00 03 	be  4000f1e4 <rtems_string_to_long_long+0x4c>  
4000f1dc:	ba 10 00 09 	mov  %o1, %i5                                  
    *endptr = end;                                                    
4000f1e0:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000f1e4:	80 a6 00 02 	cmp  %i0, %g2                                  
4000f1e8:	02 80 00 0a 	be  4000f210 <rtems_string_to_long_long+0x78>  
4000f1ec:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f1f0:	40 00 0b 59 	call  40011f54 <__errno>                       
4000f1f4:	01 00 00 00 	nop                                            
4000f1f8:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000f1fc:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000f200:	02 80 00 06 	be  4000f218 <rtems_string_to_long_long+0x80>  
4000f204:	05 1f ff ff 	sethi  %hi(0x7ffffc00), %g2                    
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000f208:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000f20c:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000f210:	81 c7 e0 08 	ret                                            
4000f214:	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 )))
4000f218:	07 3f ff ff 	sethi  %hi(0xfffffc00), %g3                    
4000f21c:	84 10 a3 ff 	or  %g2, 0x3ff, %g2                            
4000f220:	86 10 e3 ff 	or  %g3, 0x3ff, %g3                            
4000f224:	84 1f 00 02 	xor  %i4, %g2, %g2                             
4000f228:	86 1f 40 03 	xor  %i5, %g3, %g3                             
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f22c:	80 90 80 03 	orcc  %g2, %g3, %g0                            
4000f230:	12 80 00 04 	bne  4000f240 <rtems_string_to_long_long+0xa8> 
4000f234:	80 97 00 1d 	orcc  %i4, %i5, %g0                            
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
      return RTEMS_INVALID_NUMBER;                                    
4000f238:	10 bf ff f6 	b  4000f210 <rtems_string_to_long_long+0x78>   
4000f23c:	82 10 20 0a 	mov  0xa, %g1                                  
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f240:	02 bf ff f4 	be  4000f210 <rtems_string_to_long_long+0x78>  <== NEVER TAKEN
4000f244:	82 10 20 0a 	mov  0xa, %g1                                  
    (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
4000f248:	03 20 00 00 	sethi  %hi(0x80000000), %g1                    
4000f24c:	80 a7 00 01 	cmp  %i4, %g1                                  
4000f250:	32 bf ff ef 	bne,a   4000f20c <rtems_string_to_long_long+0x74><== NEVER TAKEN
4000f254:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
4000f258:	80 a7 60 00 	cmp  %i5, 0                                    
4000f25c:	22 bf ff ed 	be,a   4000f210 <rtems_string_to_long_long+0x78><== ALWAYS TAKEN
4000f260:	82 10 20 0a 	mov  0xa, %g1                                  
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000f264:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000f268:	10 bf ff ea 	b  4000f210 <rtems_string_to_long_long+0x78>   <== NOT EXECUTED
4000f26c:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

40020814 <rtems_string_to_unsigned_char>: const char *s, unsigned char *n, char **endptr, int base ) {
40020814:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
40020818:	80 a6 60 00 	cmp  %i1, 0                                    
4002081c:	02 80 00 1b 	be  40020888 <rtems_string_to_unsigned_char+0x74>
40020820:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
40020824:	40 00 6f d1 	call  4003c768 <__errno>                       
40020828:	01 00 00 00 	nop                                            
4002082c:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
40020830:	c0 2e 40 00 	clrb  [ %i1 ]                                  
                                                                      
  result = strtoul( s, &end, base );                                  
40020834:	90 10 00 18 	mov  %i0, %o0                                  
40020838:	92 07 bf fc 	add  %fp, -4, %o1                              
4002083c:	40 00 91 ef 	call  40044ff8 <strtoul>                       
40020840:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
40020844:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
40020848:	80 a6 a0 00 	cmp  %i2, 0                                    
4002084c:	02 80 00 03 	be  40020858 <rtems_string_to_unsigned_char+0x44>
40020850:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
40020854:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
40020858:	80 a6 00 02 	cmp  %i0, %g2                                  
4002085c:	02 80 00 0b 	be  40020888 <rtems_string_to_unsigned_char+0x74>
40020860:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
40020864:	40 00 6f c1 	call  4003c768 <__errno>                       
40020868:	01 00 00 00 	nop                                            
4002086c:	c2 02 00 00 	ld  [ %o0 ], %g1                               
40020870:	80 a0 60 22 	cmp  %g1, 0x22                                 
40020874:	02 80 00 0e 	be  400208ac <rtems_string_to_unsigned_char+0x98>
40020878:	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 ) {                                         
4002087c:	18 80 00 05 	bgu  40020890 <rtems_string_to_unsigned_char+0x7c>
40020880:	82 10 20 00 	clr  %g1                                       
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
40020884:	fa 2e 40 00 	stb  %i5, [ %i1 ]                              
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40020888:	81 c7 e0 08 	ret                                            
4002088c:	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;                                                   
40020890:	40 00 6f b6 	call  4003c768 <__errno>                       
40020894:	01 00 00 00 	nop                                            
    return RTEMS_INVALID_NUMBER;                                      
40020898:	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;                                                   
4002089c:	84 10 20 22 	mov  0x22, %g2                                 
400208a0:	c4 22 00 00 	st  %g2, [ %o0 ]                               
#endif                                                                
                                                                      
  *n = result;                                                        
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
400208a4:	81 c7 e0 08 	ret                                            
400208a8:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_MAX )))                     
400208ac:	84 07 7f ff 	add  %i5, -1, %g2                              
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
400208b0:	80 a0 bf fd 	cmp  %g2, -3                                   
400208b4:	18 bf ff f5 	bgu  40020888 <rtems_string_to_unsigned_char+0x74><== ALWAYS TAKEN
400208b8:	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 ) {                                         
400208bc:	10 bf ff f0 	b  4002087c <rtems_string_to_unsigned_char+0x68><== NOT EXECUTED
400208c0:	80 a7 60 ff 	cmp  %i5, 0xff                                 <== NOT EXECUTED
                                                                      

4000f3dc <rtems_string_to_unsigned_int>: const char *s, unsigned int *n, char **endptr, int base ) {
4000f3dc:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000f3e0:	80 a6 60 00 	cmp  %i1, 0                                    
4000f3e4:	02 80 00 1a 	be  4000f44c <rtems_string_to_unsigned_int+0x70>
4000f3e8:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000f3ec:	40 00 0a da 	call  40011f54 <__errno>                       
4000f3f0:	01 00 00 00 	nop                                            
4000f3f4:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000f3f8:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtoul( s, &end, base );                                  
4000f3fc:	90 10 00 18 	mov  %i0, %o0                                  
4000f400:	92 07 bf fc 	add  %fp, -4, %o1                              
4000f404:	40 00 18 2b 	call  400154b0 <strtoul>                       
4000f408:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000f40c:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
4000f410:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f414:	02 80 00 03 	be  4000f420 <rtems_string_to_unsigned_int+0x44>
4000f418:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
4000f41c:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000f420:	80 a6 00 02 	cmp  %i0, %g2                                  
4000f424:	02 80 00 0a 	be  4000f44c <rtems_string_to_unsigned_int+0x70>
4000f428:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f42c:	40 00 0a ca 	call  40011f54 <__errno>                       
4000f430:	01 00 00 00 	nop                                            
4000f434:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000f438:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000f43c:	02 80 00 06 	be  4000f454 <rtems_string_to_unsigned_int+0x78>
4000f440:	84 07 7f ff 	add  %i5, -1, %g2                              
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
4000f444:	fa 26 40 00 	st  %i5, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000f448:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000f44c:	81 c7 e0 08 	ret                                            
4000f450:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f454:	80 a0 bf fd 	cmp  %g2, -3                                   
4000f458:	18 bf ff fd 	bgu  4000f44c <rtems_string_to_unsigned_int+0x70><== ALWAYS TAKEN
4000f45c:	82 10 20 0a 	mov  0xa, %g1                                  
    errno = ERANGE;                                                   
    return RTEMS_INVALID_NUMBER;                                      
  }                                                                   
#endif                                                                
                                                                      
  *n = result;                                                        
4000f460:	10 bf ff fa 	b  4000f448 <rtems_string_to_unsigned_int+0x6c><== NOT EXECUTED
4000f464:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      

4000c98c <rtems_string_to_unsigned_long>: const char *s, unsigned long *n, char **endptr, int base ) {
4000c98c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long result;                                               
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000c990:	80 a6 60 00 	cmp  %i1, 0                                    
4000c994:	02 80 00 1a 	be  4000c9fc <rtems_string_to_unsigned_long+0x70>
4000c998:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000c99c:	40 00 bf 73 	call  4003c768 <__errno>                       
4000c9a0:	01 00 00 00 	nop                                            
4000c9a4:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000c9a8:	c0 26 40 00 	clr  [ %i1 ]                                   
                                                                      
  result = strtoul( s, &end, base );                                  
4000c9ac:	90 10 00 18 	mov  %i0, %o0                                  
4000c9b0:	92 07 bf fc 	add  %fp, -4, %o1                              
4000c9b4:	40 00 e1 91 	call  40044ff8 <strtoul>                       
4000c9b8:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000c9bc:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoul( s, &end, base );                                  
                                                                      
  if ( endptr )                                                       
4000c9c0:	80 a6 a0 00 	cmp  %i2, 0                                    
4000c9c4:	02 80 00 03 	be  4000c9d0 <rtems_string_to_unsigned_long+0x44>
4000c9c8:	ba 10 00 08 	mov  %o0, %i5                                  
    *endptr = end;                                                    
4000c9cc:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000c9d0:	80 a6 00 02 	cmp  %i0, %g2                                  
4000c9d4:	02 80 00 0a 	be  4000c9fc <rtems_string_to_unsigned_long+0x70>
4000c9d8:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000c9dc:	40 00 bf 63 	call  4003c768 <__errno>                       
4000c9e0:	01 00 00 00 	nop                                            
4000c9e4:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000c9e8:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000c9ec:	02 80 00 06 	be  4000ca04 <rtems_string_to_unsigned_long+0x78>
4000c9f0:	84 07 7f ff 	add  %i5, -1, %g2                              
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000c9f4:	fa 26 40 00 	st  %i5, [ %i1 ]                               
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000c9f8:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000c9fc:	81 c7 e0 08 	ret                                            
4000ca00:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000ca04:	80 a0 bf fd 	cmp  %g2, -3                                   
4000ca08:	18 bf ff fd 	bgu  4000c9fc <rtems_string_to_unsigned_long+0x70><== ALWAYS TAKEN
4000ca0c:	82 10 20 0a 	mov  0xa, %g1                                  
    (( result == 0 ) || ( result == ULONG_MAX )))                     
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000ca10:	10 bf ff fa 	b  4000c9f8 <rtems_string_to_unsigned_long+0x6c><== NOT EXECUTED
4000ca14:	fa 26 40 00 	st  %i5, [ %i1 ]                               <== NOT EXECUTED
                                                                      

4000f468 <rtems_string_to_unsigned_long_long>: const char *s, unsigned long long *n, char **endptr, int base ) {
4000f468:	9d e3 bf 98 	save  %sp, -104, %sp                           
  unsigned long long result;                                          
  char *end;                                                          
                                                                      
  if ( !n )                                                           
4000f46c:	80 a6 60 00 	cmp  %i1, 0                                    
4000f470:	02 80 00 1c 	be  4000f4e0 <rtems_string_to_unsigned_long_long+0x78>
4000f474:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
4000f478:	40 00 0a b7 	call  40011f54 <__errno>                       
4000f47c:	01 00 00 00 	nop                                            
4000f480:	c0 22 00 00 	clr  [ %o0 ]                                   
  *n = 0;                                                             
4000f484:	c0 26 40 00 	clr  [ %i1 ]                                   
4000f488:	c0 26 60 04 	clr  [ %i1 + 4 ]                               
                                                                      
  result = strtoull( s, &end, base );                                 
4000f48c:	90 10 00 18 	mov  %i0, %o0                                  
4000f490:	92 07 bf fc 	add  %fp, -4, %o1                              
4000f494:	40 00 18 10 	call  400154d4 <strtoull>                      
4000f498:	94 10 00 1b 	mov  %i3, %o2                                  
                                                                      
  if ( endptr )                                                       
    *endptr = end;                                                    
4000f49c:	c4 07 bf fc 	ld  [ %fp + -4 ], %g2                          
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  errno = 0;                                                          
  *n = 0;                                                             
                                                                      
  result = strtoull( s, &end, base );                                 
4000f4a0:	b8 10 00 08 	mov  %o0, %i4                                  
                                                                      
  if ( endptr )                                                       
4000f4a4:	80 a6 a0 00 	cmp  %i2, 0                                    
4000f4a8:	02 80 00 03 	be  4000f4b4 <rtems_string_to_unsigned_long_long+0x4c>
4000f4ac:	ba 10 00 09 	mov  %o1, %i5                                  
    *endptr = end;                                                    
4000f4b0:	c4 26 80 00 	st  %g2, [ %i2 ]                               
                                                                      
  if ( end == s )                                                     
4000f4b4:	80 a6 00 02 	cmp  %i0, %g2                                  
4000f4b8:	02 80 00 0a 	be  4000f4e0 <rtems_string_to_unsigned_long_long+0x78>
4000f4bc:	82 10 20 0b 	mov  0xb, %g1                                  
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f4c0:	40 00 0a a5 	call  40011f54 <__errno>                       
4000f4c4:	01 00 00 00 	nop                                            
4000f4c8:	c2 02 00 00 	ld  [ %o0 ], %g1                               
4000f4cc:	80 a0 60 22 	cmp  %g1, 0x22                                 
4000f4d0:	02 80 00 06 	be  4000f4e8 <rtems_string_to_unsigned_long_long+0x80>
4000f4d4:	86 87 7f ff 	addcc  %i5, -1, %g3                            
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000f4d8:	f8 3e 40 00 	std  %i4, [ %i1 ]                              
                                                                      
  return RTEMS_SUCCESSFUL;                                            
4000f4dc:	82 10 20 00 	clr  %g1                                       
}                                                                     
4000f4e0:	81 c7 e0 08 	ret                                            
4000f4e4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
4000f4e8:	84 47 3f ff 	addx  %i4, -1, %g2                             
    *endptr = end;                                                    
                                                                      
  if ( end == s )                                                     
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( ( errno == ERANGE ) &&                                         
4000f4ec:	80 a0 bf ff 	cmp  %g2, -1                                   
4000f4f0:	12 bf ff fa 	bne  4000f4d8 <rtems_string_to_unsigned_long_long+0x70><== NEVER TAKEN
4000f4f4:	80 a0 ff fd 	cmp  %g3, -3                                   
4000f4f8:	18 bf ff fa 	bgu  4000f4e0 <rtems_string_to_unsigned_long_long+0x78><== ALWAYS TAKEN
4000f4fc:	82 10 20 0a 	mov  0xa, %g1                                  
    (( result == 0 ) || ( result == ULONG_LONG_MAX )))                
      return RTEMS_INVALID_NUMBER;                                    
                                                                      
  *n = result;                                                        
4000f500:	10 bf ff f7 	b  4000f4dc <rtems_string_to_unsigned_long_long+0x74><== NOT EXECUTED
4000f504:	f8 3e 40 00 	std  %i4, [ %i1 ]                              <== NOT EXECUTED
                                                                      

40003d3c <rtems_tarfs_load>: int rtems_tarfs_load( const char *mountpoint, uint8_t *tar_image, size_t tar_size ) {
40003d3c:	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 =                     
40003d40:	94 10 20 18 	mov  0x18, %o2                                 
40003d44:	92 10 00 18 	mov  %i0, %o1                                  
40003d48:	40 00 08 18 	call  40005da8 <rtems_filesystem_eval_path_start>
40003d4c:	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(                          
40003d50:	92 07 be 78 	add  %fp, -392, %o1                            
40003d54:	aa 10 00 08 	mov  %o0, %l5                                  
40003d58:	40 00 09 0d 	call  4000618c <rtems_filesystem_location_copy_and_detach>
40003d5c:	90 07 be 48 	add  %fp, -440, %o0                            
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
     rootloc.mt_entry->ops != &IMFS_ops                               
40003d60:	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;                                                 
40003d64:	84 10 20 60 	mov  0x60, %g2                                 
40003d68:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40003d6c:	c4 27 be 70 	st  %g2, [ %fp + -400 ]                        
   rtems_filesystem_eval_path_set_flags(                              
     &ctx,                                                            
     RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE                               
   );                                                                 
                                                                      
   if (                                                               
40003d70:	05 10 00 8a 	sethi  %hi(0x40022800), %g2                    
40003d74:	84 10 a2 e8 	or  %g2, 0x2e8, %g2	! 40022ae8 <IMFS_ops>      
40003d78:	80 a0 40 02 	cmp  %g1, %g2                                  
40003d7c:	02 80 00 06 	be  40003d94 <rtems_tarfs_load+0x58>           
40003d80:	05 10 00 8d 	sethi  %hi(0x40023400), %g2                    
     rootloc.mt_entry->ops != &IMFS_ops                               
       && rootloc.mt_entry->ops != &fifoIMFS_ops                      
40003d84:	84 10 a2 28 	or  %g2, 0x228, %g2	! 40023628 <fifoIMFS_ops>  
40003d88:	80 a0 40 02 	cmp  %g1, %g2                                  
40003d8c:	12 80 00 78 	bne  40003f6c <rtems_tarfs_load+0x230>         <== ALWAYS TAKEN
40003d90:	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)                                      
40003d94:	80 a6 a1 ff 	cmp  %i2, 0x1ff                                
40003d98:	08 80 00 4b 	bleu  40003ec4 <rtems_tarfs_load+0x188>        <== NEVER TAKEN
40003d9c:	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);                              
40003da0:	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))                           
40003da4:	27 10 00 8a 	sethi  %hi(0x40022800), %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);                              
40003da8:	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)                                      
40003dac:	a2 10 22 00 	mov  0x200, %l1                                
40003db0:	b8 10 22 00 	mov  0x200, %i4                                
40003db4:	ba 10 20 00 	clr  %i5                                       
    /*                                                                
     * Read a header.                                                 
     */                                                               
    hdr_ptr = (char *) &tar_image[offset];                            
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
40003db8:	a6 14 e3 70 	or  %l3, 0x370, %l3                            
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
40003dbc:	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);                              
40003dc0:	10 80 00 08 	b  40003de0 <rtems_tarfs_load+0xa4>            
40003dc4:	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) {                                   
40003dc8:	02 80 00 46 	be  40003ee0 <rtems_tarfs_load+0x1a4>          
40003dcc:	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)                                      
40003dd0:	b8 07 62 00 	add  %i5, 0x200, %i4                           
40003dd4:	80 a7 00 1a 	cmp  %i4, %i2                                  
40003dd8:	18 80 00 3b 	bgu  40003ec4 <rtems_tarfs_load+0x188>         <== NEVER TAKEN
40003ddc:	a2 10 00 1c 	mov  %i4, %l1                                  
      break;                                                          
                                                                      
    /*                                                                
     * Read a header.                                                 
     */                                                               
    hdr_ptr = (char *) &tar_image[offset];                            
40003de0:	ba 06 40 1d 	add  %i1, %i5, %i5                             
    offset += 512;                                                    
    if (strncmp(&hdr_ptr[257], "ustar", 5))                           
40003de4:	92 10 00 13 	mov  %l3, %o1                                  
40003de8:	90 07 61 01 	add  %i5, 0x101, %o0                           
40003dec:	40 00 46 a4 	call  4001587c <strncmp>                       
40003df0:	94 10 20 05 	mov  5, %o2                                    
40003df4:	80 a2 20 00 	cmp  %o0, 0                                    
40003df8:	12 80 00 33 	bne  40003ec4 <rtems_tarfs_load+0x188>         
40003dfc:	94 10 20 63 	mov  0x63, %o2                                 
      break;                                                          
                                                                      
    strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);                  
40003e00:	92 10 00 1d 	mov  %i5, %o1                                  
40003e04:	40 00 46 f4 	call  400159d4 <strncpy>                       
40003e08:	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);                
40003e0c:	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';                             
40003e10:	c0 2f be fb 	clrb  [ %fp + -261 ]                           
                                                                      
    linkflag   = hdr_ptr[156];                                        
40003e14:	f6 0f 60 9c 	ldub  [ %i5 + 0x9c ], %i3                      
    file_mode  = _rtems_octal2ulong(&hdr_ptr[100], 8);                
40003e18:	40 00 23 d5 	call  4000cd6c <_rtems_octal2ulong>            
40003e1c:	90 07 60 64 	add  %i5, 0x64, %o0                            
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
40003e20:	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);                
40003e24:	a8 10 00 08 	mov  %o0, %l4                                  
    file_size  = _rtems_octal2ulong(&hdr_ptr[124], 12);               
40003e28:	40 00 23 d1 	call  4000cd6c <_rtems_octal2ulong>            
40003e2c:	90 07 60 7c 	add  %i5, 0x7c, %o0                            
    hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);                
40003e30:	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);               
40003e34:	a4 10 00 08 	mov  %o0, %l2                                  
    hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);                
40003e38:	40 00 23 cd 	call  4000cd6c <_rtems_octal2ulong>            
40003e3c:	90 07 60 94 	add  %i5, 0x94, %o0                            
40003e40:	ae 10 00 08 	mov  %o0, %l7                                  
                                                                      
    if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)            
40003e44:	40 00 25 24 	call  4000d2d4 <_rtems_tar_header_checksum>    
40003e48:	90 10 00 1d 	mov  %i5, %o0                                  
40003e4c:	80 a2 00 17 	cmp  %o0, %l7                                  
40003e50:	12 80 00 1d 	bne  40003ec4 <rtems_tarfs_load+0x188>         <== NEVER TAKEN
40003e54:	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) {                                        
40003e58:	b6 0e e0 ff 	and  %i3, 0xff, %i3                            
40003e5c:	80 a6 e0 35 	cmp  %i3, 0x35                                 
40003e60:	12 bf ff da 	bne  40003dc8 <rtems_tarfs_load+0x8c>          
40003e64:	80 a6 e0 30 	cmp  %i3, 0x30                                 
      strcpy(full_filename, mountpoint);                              
40003e68:	90 10 00 16 	mov  %l6, %o0                                  
40003e6c:	40 00 44 20 	call  40014eec <stpcpy>                        
40003e70:	92 10 00 18 	mov  %i0, %o1                                  
      if (full_filename[strlen(full_filename)-1] != '/')              
40003e74:	c4 07 be 44 	ld  [ %fp + -444 ], %g2                        
40003e78:	82 07 80 08 	add  %fp, %o0, %g1                             
40003e7c:	82 00 40 02 	add  %g1, %g2, %g1                             
40003e80:	c2 48 7f 00 	ldsb  [ %g1 + -256 ], %g1                      
40003e84:	80 a0 60 2f 	cmp  %g1, 0x2f                                 
40003e88:	02 80 00 04 	be  40003e98 <rtems_tarfs_load+0x15c>          <== ALWAYS TAKEN
40003e8c:	82 10 20 2f 	mov  0x2f, %g1                                 
        strcat(full_filename, "/");                                   
40003e90:	c0 2a 20 01 	clrb  [ %o0 + 1 ]                              <== NOT EXECUTED
40003e94:	c2 2a 00 00 	stb  %g1, [ %o0 ]                              <== NOT EXECUTED
      strcat(full_filename, filename);                                
40003e98:	92 10 00 10 	mov  %l0, %o1                                  
40003e9c:	40 00 44 33 	call  40014f68 <strcat>                        
40003ea0:	90 10 00 16 	mov  %l6, %o0                                  
      mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);              
40003ea4:	90 10 00 16 	mov  %l6, %o0                                  
40003ea8:	40 00 04 14 	call  40004ef8 <mkdir>                         
40003eac:	92 10 21 ff 	mov  0x1ff, %o1                                
40003eb0:	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)                                      
40003eb4:	b8 07 62 00 	add  %i5, 0x200, %i4                           
40003eb8:	80 a7 00 1a 	cmp  %i4, %i2                                  
40003ebc:	08 bf ff c9 	bleu  40003de0 <rtems_tarfs_load+0xa4>         <== ALWAYS TAKEN
40003ec0:	a2 10 00 1c 	mov  %i4, %l1                                  
      nblocks = (((file_size) + 511) & ~511) / 512;                   
      offset += 512 * nblocks;                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_filesystem_location_free( &rootloc );                         
40003ec4:	40 00 02 6e 	call  4000487c <rtems_filesystem_location_free>
40003ec8:	90 07 be 48 	add  %fp, -440, %o0                            
                                                                      
   if (                                                               
     rootloc.mt_entry->ops != &IMFS_ops                               
       && rootloc.mt_entry->ops != &fifoIMFS_ops                      
   ) {                                                                
     rv = -1;                                                         
40003ecc:	b0 10 20 00 	clr  %i0                                       
      offset += 512 * nblocks;                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_filesystem_location_free( &rootloc );                         
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40003ed0:	40 00 07 f6 	call  40005ea8 <rtems_filesystem_eval_path_cleanup>
40003ed4:	90 07 be 60 	add  %fp, -416, %o0                            
40003ed8:	81 c7 e0 08 	ret                                            
40003edc:	81 e8 00 00 	restore                                        
    }                                                                 
    /*                                                                
     * Create a LINEAR_FILE node                                      
     */                                                               
    else if (linkflag == REGTYPE) {                                   
      rtems_filesystem_location_free( currentloc );                   
40003ee0:	40 00 02 67 	call  4000487c <rtems_filesystem_location_free>
40003ee4:	90 10 00 15 	mov  %l5, %o0                                  
      rtems_filesystem_location_clone( currentloc, &rootloc );        
40003ee8:	92 07 be 48 	add  %fp, -440, %o1                            
40003eec:	40 00 01 96 	call  40004544 <rtems_filesystem_location_clone>
40003ef0:	90 10 00 15 	mov  %l5, %o0                                  
      rtems_filesystem_eval_path_set_path(                            
40003ef4:	40 00 46 30 	call  400157b4 <strlen>                        
40003ef8:	90 10 00 10 	mov  %l0, %o0                                  
  rtems_filesystem_eval_path_context_t *ctx,                          
  const char *path,                                                   
  size_t pathlen                                                      
)                                                                     
{                                                                     
  ctx->path = path;                                                   
40003efc:	e0 27 be 60 	st  %l0, [ %fp + -416 ]                        
  ctx->pathlen = pathlen;                                             
40003f00:	d0 27 be 64 	st  %o0, [ %fp + -412 ]                        
        &ctx,                                                         
        filename,                                                     
        strlen( filename )                                            
      );                                                              
      rtems_filesystem_eval_path_continue( &ctx );                    
40003f04:	40 00 07 2c 	call  40005bb4 <rtems_filesystem_eval_path_continue>
40003f08:	90 07 be 60 	add  %fp, -416, %o0                            
                                                                      
      if ( !rtems_filesystem_location_is_null( currentloc ) ) {       
40003f0c:	c2 05 60 10 	ld  [ %l5 + 0x10 ], %g1                        
40003f10:	05 10 00 8c 	sethi  %hi(0x40023000), %g2                    
40003f14:	84 10 a3 84 	or  %g2, 0x384, %g2	! 40023384 <rtems_filesystem_null_handlers>
40003f18:	80 a0 40 02 	cmp  %g1, %g2                                  
40003f1c:	02 80 00 10 	be  40003f5c <rtems_tarfs_load+0x220>          <== NEVER TAKEN
40003f20:	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 =                                     
40003f24:	c2 05 60 14 	ld  [ %l5 + 0x14 ], %g1                        
    (const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;            
                                                                      
  return IMFS_create_node_with_control(                               
40003f28:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40003f2c:	d6 07 be 6c 	ld  [ %fp + -404 ], %o3                        
40003f30:	d2 00 60 1c 	ld  [ %g1 + 0x1c ], %o1                        
40003f34:	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,      
40003f38:	98 0d 21 ff 	and  %l4, 0x1ff, %o4                           
40003f3c:	90 10 00 15 	mov  %l5, %o0                                  
40003f40:	98 13 00 01 	or  %o4, %g1, %o4                              
40003f44:	40 00 25 9e 	call  4000d5bc <IMFS_create_node_with_control> 
40003f48:	9a 10 20 00 	clr  %o5                                       
          NULL                                                        
        );                                                            
        node->info.linearfile.size   = file_size;                     
        node->info.linearfile.direct = &tar_image[offset];            
40003f4c:	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;                     
40003f50:	c0 22 20 50 	clr  [ %o0 + 0x50 ]                            
40003f54:	e4 22 20 54 	st  %l2, [ %o0 + 0x54 ]                        
        node->info.linearfile.direct = &tar_image[offset];            
40003f58:	c2 22 20 58 	st  %g1, [ %o0 + 0x58 ]                        
      }                                                               
                                                                      
      nblocks = (((file_size) + 511) & ~511) / 512;                   
40003f5c:	ba 04 a1 ff 	add  %l2, 0x1ff, %i5                           
      offset += 512 * nblocks;                                        
40003f60:	ba 0f 7e 00 	and  %i5, -512, %i5                            
40003f64:	10 bf ff 9b 	b  40003dd0 <rtems_tarfs_load+0x94>            
40003f68:	ba 07 40 11 	add  %i5, %l1, %i5                             
    }                                                                 
  }                                                                   
                                                                      
  rtems_filesystem_location_free( &rootloc );                         
40003f6c:	40 00 02 44 	call  4000487c <rtems_filesystem_location_free>
40003f70:	90 07 be 48 	add  %fp, -440, %o0                            
                                                                      
   if (                                                               
     rootloc.mt_entry->ops != &IMFS_ops                               
       && rootloc.mt_entry->ops != &fifoIMFS_ops                      
   ) {                                                                
     rv = -1;                                                         
40003f74:	b0 10 3f ff 	mov  -1, %i0                                   
      offset += 512 * nblocks;                                        
    }                                                                 
  }                                                                   
                                                                      
  rtems_filesystem_location_free( &rootloc );                         
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40003f78:	40 00 07 cc 	call  40005ea8 <rtems_filesystem_eval_path_cleanup>
40003f7c:	90 07 be 60 	add  %fp, -416, %o0                            
40003f80:	81 c7 e0 08 	ret                                            
40003f84:	81 e8 00 00 	restore                                        
                                                                      

4001298c <rtems_task_mode>: rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) {
4001298c:	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 )                                           
40012990:	80 a6 a0 00 	cmp  %i2, 0                                    
40012994:	02 80 00 3b 	be  40012a80 <rtems_task_mode+0xf4>            
40012998:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  executing     = _Thread_Executing;                                  
4001299c:	21 10 00 73 	sethi  %hi(0x4001cc00), %l0                    
400129a0:	a0 14 23 b0 	or  %l0, 0x3b0, %l0	! 4001cfb0 <_Per_CPU_Information>
400129a4:	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;
400129a8:	c4 0f 60 70 	ldub  [ %i5 + 0x70 ], %g2                      
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
400129ac:	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;
400129b0:	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 ];                
400129b4:	f8 07 61 4c 	ld  [ %i5 + 0x14c ], %i4                       
  asr = &api->Signal;                                                 
                                                                      
  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
400129b8:	b6 60 3f ff 	subx  %g0, -1, %i3                             
                                                                      
  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
400129bc:	80 a0 60 00 	cmp  %g1, 0                                    
400129c0:	12 80 00 40 	bne  40012ac0 <rtems_task_mode+0x134>          
400129c4:	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;           
400129c8:	c2 0f 20 08 	ldub  [ %i4 + 8 ], %g1                         
400129cc:	80 a0 00 01 	cmp  %g0, %g1                                  
  old_mode |= _ISR_Get_level();                                       
400129d0:	7f ff eb e1 	call  4000d954 <_CPU_ISR_Get_level>            
400129d4:	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;           
400129d8:	a3 2c 60 0a 	sll  %l1, 0xa, %l1                             
400129dc:	90 14 40 08 	or  %l1, %o0, %o0                              
  old_mode |= _ISR_Get_level();                                       
400129e0:	b6 12 00 1b 	or  %o0, %i3, %i3                              
  *previous_mode_set = old_mode;                                      
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
400129e4:	80 8e 61 00 	btst  0x100, %i1                               
400129e8:	02 80 00 06 	be  40012a00 <rtems_task_mode+0x74>            
400129ec:	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;           
400129f0:	83 36 20 08 	srl  %i0, 8, %g1                               
400129f4:	82 18 60 01 	xor  %g1, 1, %g1                               
400129f8:	82 08 60 01 	and  %g1, 1, %g1                               
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
400129fc:	c2 2f 60 70 	stb  %g1, [ %i5 + 0x70 ]                       
                                                                      
  if ( mask & RTEMS_TIMESLICE_MASK ) {                                
40012a00:	80 8e 62 00 	btst  0x200, %i1                               
40012a04:	12 80 00 21 	bne  40012a88 <rtems_task_mode+0xfc>           
40012a08:	80 8e 22 00 	btst  0x200, %i0                               
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
40012a0c:	80 8e 60 0f 	btst  0xf, %i1                                 
40012a10:	12 80 00 27 	bne  40012aac <rtems_task_mode+0x120>          
40012a14:	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 ) {                                      
40012a18:	80 8e 64 00 	btst  0x400, %i1                               
40012a1c:	02 80 00 14 	be  40012a6c <rtems_task_mode+0xe0>            
40012a20:	86 10 20 00 	clr  %g3                                       
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {                        
40012a24:	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;
40012a28:	b1 36 20 0a 	srl  %i0, 0xa, %i0                             
40012a2c:	b0 1e 20 01 	xor  %i0, 1, %i0                               
40012a30:	b0 0e 20 01 	and  %i0, 1, %i0                               
    if ( is_asr_enabled != asr->is_enabled ) {                        
40012a34:	80 a6 00 01 	cmp  %i0, %g1                                  
40012a38:	22 80 00 0e 	be,a   40012a70 <rtems_task_mode+0xe4>         
40012a3c:	03 10 00 73 	sethi  %hi(0x4001cc00), %g1                    
)                                                                     
{                                                                     
  rtems_signal_set _signals;                                          
  ISR_Level        _level;                                            
                                                                      
  _ISR_Disable( _level );                                             
40012a40:	7f ff c0 5e 	call  40002bb8 <sparc_disable_interrupts>      
40012a44:	f0 2f 20 08 	stb  %i0, [ %i4 + 8 ]                          
    _signals                     = information->signals_pending;      
40012a48:	c4 07 20 18 	ld  [ %i4 + 0x18 ], %g2                        
    information->signals_pending = information->signals_posted;       
40012a4c:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
    information->signals_posted  = _signals;                          
40012a50:	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;       
40012a54:	c2 27 20 18 	st  %g1, [ %i4 + 0x18 ]                        
    information->signals_posted  = _signals;                          
  _ISR_Enable( _level );                                              
40012a58:	7f ff c0 5c 	call  40002bc8 <sparc_enable_interrupts>       
40012a5c:	01 00 00 00 	nop                                            
      asr->is_enabled = is_asr_enabled;                               
      _ASR_Swap_signals( asr );                                       
      if ( _ASR_Are_signals_pending( asr ) ) {                        
40012a60:	c2 07 20 14 	ld  [ %i4 + 0x14 ], %g1                        
40012a64:	80 a0 00 01 	cmp  %g0, %g1                                  
40012a68:	86 40 20 00 	addx  %g0, 0, %g3                              
        needs_asr_dispatching = true;                                 
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  if ( _System_state_Is_up( _System_state_Get() ) ) {                 
40012a6c:	03 10 00 73 	sethi  %hi(0x4001cc00), %g1                    
40012a70:	c4 00 63 a8 	ld  [ %g1 + 0x3a8 ], %g2	! 4001cfa8 <_System_state_Current>
40012a74:	80 a0 a0 03 	cmp  %g2, 3                                    
40012a78:	02 80 00 1f 	be  40012af4 <rtems_task_mode+0x168>           
40012a7c:	82 10 20 00 	clr  %g1                                       
     if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
      _Thread_Dispatch();                                             
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40012a80:	81 c7 e0 08 	ret                                            
40012a84:	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) ) {                            
40012a88:	22 bf ff e1 	be,a   40012a0c <rtems_task_mode+0x80>         
40012a8c:	c0 27 60 78 	clr  [ %i5 + 0x78 ]                            
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;      
40012a90:	03 10 00 72 	sethi  %hi(0x4001c800), %g1                    
40012a94:	c2 00 62 00 	ld  [ %g1 + 0x200 ], %g1	! 4001ca00 <_Thread_Ticks_per_timeslice>
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
40012a98:	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;      
40012a9c:	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;
40012aa0:	82 10 20 01 	mov  1, %g1                                    
  }                                                                   
                                                                      
  /*                                                                  
   *  Set the new interrupt level                                     
   */                                                                 
  if ( mask & RTEMS_INTERRUPT_MASK )                                  
40012aa4:	02 bf ff dd 	be  40012a18 <rtems_task_mode+0x8c>            
40012aa8:	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 );                         
40012aac:	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 ) );           
40012ab0:	7f ff c0 46 	call  40002bc8 <sparc_enable_interrupts>       
40012ab4:	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 ) {                                      
40012ab8:	10 bf ff d9 	b  40012a1c <rtems_task_mode+0x90>             
40012abc:	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;           
40012ac0:	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;                                      
40012ac4:	b6 16 e2 00 	or  %i3, 0x200, %i3                            
                                                                      
  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;           
40012ac8:	80 a0 00 01 	cmp  %g0, %g1                                  
  old_mode |= _ISR_Get_level();                                       
40012acc:	7f ff eb a2 	call  4000d954 <_CPU_ISR_Get_level>            
40012ad0:	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;           
40012ad4:	a3 2c 60 0a 	sll  %l1, 0xa, %l1                             
40012ad8:	90 14 40 08 	or  %l1, %o0, %o0                              
  old_mode |= _ISR_Get_level();                                       
40012adc:	b6 12 00 1b 	or  %o0, %i3, %i3                              
  *previous_mode_set = old_mode;                                      
                                                                      
  /*                                                                  
   *  These are generic thread scheduling characteristics.            
   */                                                                 
  if ( mask & RTEMS_PREEMPT_MASK )                                    
40012ae0:	80 8e 61 00 	btst  0x100, %i1                               
40012ae4:	02 bf ff c7 	be  40012a00 <rtems_task_mode+0x74>            
40012ae8:	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;           
40012aec:	10 bf ff c2 	b  400129f4 <rtems_task_mode+0x68>             
40012af0:	83 36 20 08 	srl  %i0, 8, %g1                               
{                                                                     
  Thread_Control     *executing;                                      
                                                                      
  executing = _Thread_Executing;                                      
                                                                      
  if ( are_signals_pending ||                                         
40012af4:	80 88 e0 ff 	btst  0xff, %g3                                
40012af8:	12 80 00 0a 	bne  40012b20 <rtems_task_mode+0x194>          
40012afc:	c4 04 20 10 	ld  [ %l0 + 0x10 ], %g2                        
40012b00:	c6 04 20 14 	ld  [ %l0 + 0x14 ], %g3                        
40012b04:	80 a0 80 03 	cmp  %g2, %g3                                  
40012b08:	02 bf ff de 	be  40012a80 <rtems_task_mode+0xf4>            
40012b0c:	01 00 00 00 	nop                                            
       (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
40012b10:	c4 08 a0 70 	ldub  [ %g2 + 0x70 ], %g2                      
40012b14:	80 a0 a0 00 	cmp  %g2, 0                                    
40012b18:	02 bf ff da 	be  40012a80 <rtems_task_mode+0xf4>            <== NEVER TAKEN
40012b1c:	01 00 00 00 	nop                                            
    _Thread_Dispatch_necessary = true;                                
40012b20:	82 10 20 01 	mov  1, %g1	! 1 <PROM_START+0x1>               
40012b24:	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();                                             
40012b28:	7f ff e6 66 	call  4000c4c0 <_Thread_Dispatch>              
40012b2c:	01 00 00 00 	nop                                            
  }                                                                   
                                                                      
  return RTEMS_SUCCESSFUL;                                            
40012b30:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
}                                                                     
40012b34:	81 c7 e0 08 	ret                                            
40012b38:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

4000cf44 <rtems_task_set_priority>: rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) {
4000cf44:	9d e3 bf 98 	save  %sp, -104, %sp                           
  register Thread_Control *the_thread;                                
  Objects_Locations        location;                                  
                                                                      
  if ( new_priority != RTEMS_CURRENT_PRIORITY &&                      
4000cf48:	80 a6 60 00 	cmp  %i1, 0                                    
4000cf4c:	02 80 00 08 	be  4000cf6c <rtems_task_set_priority+0x28>    
4000cf50:	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 ) );             
4000cf54:	03 10 00 6e 	sethi  %hi(0x4001b800), %g1                    
4000cf58:	c4 08 63 8c 	ldub  [ %g1 + 0x38c ], %g2	! 4001bb8c <rtems_maximum_priority>
 */                                                                   
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (            
  rtems_task_priority the_priority                                    
)                                                                     
{                                                                     
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&             
4000cf5c:	80 a6 40 02 	cmp  %i1, %g2                                  
4000cf60:	18 80 00 1e 	bgu  4000cfd8 <rtems_task_set_priority+0x94>   
4000cf64:	82 10 20 13 	mov  0x13, %g1                                 
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )              
    return RTEMS_INVALID_PRIORITY;                                    
                                                                      
  if ( !old_priority )                                                
4000cf68:	80 a6 a0 00 	cmp  %i2, 0                                    
4000cf6c:	02 80 00 1b 	be  4000cfd8 <rtems_task_set_priority+0x94>    
4000cf70:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get( id, &location );                          
4000cf74:	90 10 00 18 	mov  %i0, %o0                                  
4000cf78:	40 00 0a 22 	call  4000f800 <_Thread_Get>                   
4000cf7c:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch ( location ) {                                               
4000cf80:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000cf84:	80 a0 60 00 	cmp  %g1, 0                                    
4000cf88:	12 80 00 16 	bne  4000cfe0 <rtems_task_set_priority+0x9c>   
4000cf8c:	82 10 20 04 	mov  4, %g1                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      /* XXX need helper to "convert" from core priority */           
      *old_priority = the_thread->current_priority;                   
4000cf90:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {                 
4000cf94:	80 a6 60 00 	cmp  %i1, 0                                    
4000cf98:	02 80 00 0d 	be  4000cfcc <rtems_task_set_priority+0x88>    
4000cf9c:	c2 26 80 00 	st  %g1, [ %i2 ]                               
        the_thread->real_priority = new_priority;                     
        if ( the_thread->resource_count == 0 ||                       
4000cfa0:	c2 02 20 1c 	ld  [ %o0 + 0x1c ], %g1                        
4000cfa4:	80 a0 60 00 	cmp  %g1, 0                                    
4000cfa8:	02 80 00 06 	be  4000cfc0 <rtems_task_set_priority+0x7c>    
4000cfac:	f2 22 20 18 	st  %i1, [ %o0 + 0x18 ]                        
4000cfb0:	c2 02 20 14 	ld  [ %o0 + 0x14 ], %g1                        
4000cfb4:	80 a6 40 01 	cmp  %i1, %g1                                  
4000cfb8:	1a 80 00 05 	bcc  4000cfcc <rtems_task_set_priority+0x88>   <== ALWAYS TAKEN
4000cfbc:	01 00 00 00 	nop                                            
             the_thread->current_priority > new_priority )            
          _Thread_Change_priority( the_thread, new_priority, false ); 
4000cfc0:	92 10 00 19 	mov  %i1, %o1                                  
4000cfc4:	40 00 08 c9 	call  4000f2e8 <_Thread_Change_priority>       
4000cfc8:	94 10 20 00 	clr  %o2                                       
      }                                                               
      _Thread_Enable_dispatch();                                      
4000cfcc:	40 00 0a 01 	call  4000f7d0 <_Thread_Enable_dispatch>       
4000cfd0:	01 00 00 00 	nop                                            
      return RTEMS_SUCCESSFUL;                                        
4000cfd4:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
4000cfd8:	81 c7 e0 08 	ret                                            
4000cfdc:	91 e8 00 01 	restore  %g0, %g1, %o0                         
4000cfe0:	81 c7 e0 08 	ret                                            
4000cfe4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
                                                                      

4000716c <rtems_task_variable_delete>: rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) {
4000716c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp, *prev;                                  
                                                                      
  if ( !ptr )                                                         
40007170:	80 a6 60 00 	cmp  %i1, 0                                    
40007174:	02 80 00 1e 	be  400071ec <rtems_task_variable_delete+0x80> 
40007178:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  prev = NULL;                                                        
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
4000717c:	90 10 00 18 	mov  %i0, %o0                                  
40007180:	40 00 08 b1 	call  40009444 <_Thread_Get>                   
40007184:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch (location) {                                                 
40007188:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000718c:	80 a0 60 00 	cmp  %g1, 0                                    
40007190:	12 80 00 19 	bne  400071f4 <rtems_task_variable_delete+0x88>
40007194:	82 10 20 04 	mov  4, %g1                                    
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
40007198:	c2 02 21 58 	ld  [ %o0 + 0x158 ], %g1                       
      while (tvp) {                                                   
4000719c:	80 a0 60 00 	cmp  %g1, 0                                    
400071a0:	02 80 00 10 	be  400071e0 <rtems_task_variable_delete+0x74> 
400071a4:	01 00 00 00 	nop                                            
        if (tvp->ptr == ptr) {                                        
400071a8:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
400071ac:	80 a0 80 19 	cmp  %g2, %i1                                  
400071b0:	32 80 00 09 	bne,a   400071d4 <rtems_task_variable_delete+0x68>
400071b4:	d2 00 40 00 	ld  [ %g1 ], %o1                               
          if (prev)                                                   
            prev->next = tvp->next;                                   
          else                                                        
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
400071b8:	10 80 00 18 	b  40007218 <rtems_task_variable_delete+0xac>  
400071bc:	c4 00 40 00 	ld  [ %g1 ], %g2                               
  switch (location) {                                                 
                                                                      
    case OBJECTS_LOCAL:                                               
      tvp = the_thread->task_variables;                               
      while (tvp) {                                                   
        if (tvp->ptr == ptr) {                                        
400071c0:	80 a0 80 19 	cmp  %g2, %i1                                  
400071c4:	22 80 00 0e 	be,a   400071fc <rtems_task_variable_delete+0x90>
400071c8:	c4 02 40 00 	ld  [ %o1 ], %g2                               
400071cc:	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;                     
400071d0:	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) {                                                   
400071d4:	80 a2 60 00 	cmp  %o1, 0                                    
400071d8:	32 bf ff fa 	bne,a   400071c0 <rtems_task_variable_delete+0x54><== ALWAYS TAKEN
400071dc:	c4 02 60 04 	ld  [ %o1 + 4 ], %g2                           
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        prev = tvp;                                                   
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
400071e0:	40 00 08 8d 	call  40009414 <_Thread_Enable_dispatch>       
400071e4:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_ADDRESS;                                   
400071e8:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
    case OBJECTS_ERROR:                                               
        break;                                                        
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400071ec:	81 c7 e0 08 	ret                                            
400071f0:	91 e8 00 01 	restore  %g0, %g1, %o0                         
400071f4:	81 c7 e0 08 	ret                                            
400071f8:	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;                                   
400071fc:	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 );  
40007200:	40 00 00 2e 	call  400072b8 <_RTEMS_Tasks_Invoke_task_variable_dtor>
40007204:	01 00 00 00 	nop                                            
          _Thread_Enable_dispatch();                                  
40007208:	40 00 08 83 	call  40009414 <_Thread_Enable_dispatch>       
4000720c:	01 00 00 00 	nop                                            
          return RTEMS_SUCCESSFUL;                                    
40007210:	10 bf ff f7 	b  400071ec <rtems_task_variable_delete+0x80>  
40007214:	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;
40007218:	92 10 00 01 	mov  %g1, %o1                                  
4000721c:	10 bf ff f9 	b  40007200 <rtems_task_variable_delete+0x94>  
40007220:	c4 22 21 58 	st  %g2, [ %o0 + 0x158 ]                       
                                                                      

40007224 <rtems_task_variable_get>: rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) {
40007224:	9d e3 bf 98 	save  %sp, -104, %sp                           
  Thread_Control        *the_thread;                                  
  Objects_Locations      location;                                    
  rtems_task_variable_t *tvp;                                         
                                                                      
  if ( !ptr )                                                         
40007228:	80 a6 60 00 	cmp  %i1, 0                                    
4000722c:	02 80 00 1b 	be  40007298 <rtems_task_variable_get+0x74>    
40007230:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !result )                                                      
40007234:	80 a6 a0 00 	cmp  %i2, 0                                    
40007238:	02 80 00 18 	be  40007298 <rtems_task_variable_get+0x74>    
4000723c:	90 10 00 18 	mov  %i0, %o0                                  
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  the_thread = _Thread_Get (tid, &location);                          
40007240:	40 00 08 81 	call  40009444 <_Thread_Get>                   
40007244:	92 07 bf fc 	add  %fp, -4, %o1                              
  switch (location) {                                                 
40007248:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
4000724c:	80 a0 60 00 	cmp  %g1, 0                                    
40007250:	12 80 00 14 	bne  400072a0 <rtems_task_variable_get+0x7c>   
40007254:	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;                               
40007258:	c2 02 21 58 	ld  [ %o0 + 0x158 ], %g1                       
      while (tvp) {                                                   
4000725c:	80 a0 60 00 	cmp  %g1, 0                                    
40007260:	32 80 00 07 	bne,a   4000727c <rtems_task_variable_get+0x58>
40007264:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
40007268:	30 80 00 10 	b,a   400072a8 <rtems_task_variable_get+0x84>  
4000726c:	80 a0 60 00 	cmp  %g1, 0                                    
40007270:	02 80 00 0e 	be  400072a8 <rtems_task_variable_get+0x84>    <== NEVER TAKEN
40007274:	01 00 00 00 	nop                                            
        if (tvp->ptr == ptr) {                                        
40007278:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
4000727c:	80 a0 80 19 	cmp  %g2, %i1                                  
40007280:	32 bf ff fb 	bne,a   4000726c <rtems_task_variable_get+0x48>
40007284:	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;                                        
40007288:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
          _Thread_Enable_dispatch();                                  
4000728c:	40 00 08 62 	call  40009414 <_Thread_Enable_dispatch>       
40007290:	c2 26 80 00 	st  %g1, [ %i2 ]                               
          return RTEMS_SUCCESSFUL;                                    
40007294:	82 10 20 00 	clr  %g1                                       
                                                                      
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
  return RTEMS_INVALID_ID;                                            
}                                                                     
40007298:	81 c7 e0 08 	ret                                            
4000729c:	91 e8 00 01 	restore  %g0, %g1, %o0                         
400072a0:	81 c7 e0 08 	ret                                            
400072a4:	91 e8 00 01 	restore  %g0, %g1, %o0                         
          _Thread_Enable_dispatch();                                  
          return RTEMS_SUCCESSFUL;                                    
        }                                                             
        tvp = (rtems_task_variable_t *)tvp->next;                     
      }                                                               
      _Thread_Enable_dispatch();                                      
400072a8:	40 00 08 5b 	call  40009414 <_Thread_Enable_dispatch>       
400072ac:	01 00 00 00 	nop                                            
      return RTEMS_INVALID_ADDRESS;                                   
400072b0:	10 bf ff fa 	b  40007298 <rtems_task_variable_get+0x74>     
400072b4:	82 10 20 09 	mov  9, %g1	! 9 <PROM_START+0x9>               
                                                                      

40006ed0 <rtems_termios_baud_to_index>: rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) {
40006ed0:	80 a2 20 09 	cmp  %o0, 9                                    
40006ed4:	02 80 00 1c 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006ed8:	82 10 20 09 	mov  9, %g1                                    
40006edc:	80 a2 20 09 	cmp  %o0, 9                                    
40006ee0:	08 80 00 1b 	bleu  40006f4c <rtems_termios_baud_to_index+0x7c>
40006ee4:	80 a2 20 04 	cmp  %o0, 4                                    
40006ee8:	80 a2 20 0e 	cmp  %o0, 0xe                                  
40006eec:	02 80 00 16 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006ef0:	82 10 20 0e 	mov  0xe, %g1                                  
40006ef4:	80 a2 20 0e 	cmp  %o0, 0xe                                  
40006ef8:	08 80 00 28 	bleu  40006f98 <rtems_termios_baud_to_index+0xc8>
40006efc:	80 a2 20 0b 	cmp  %o0, 0xb                                  
40006f00:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
40006f04:	86 10 a0 02 	or  %g2, 2, %g3	! 1002 <PROM_START+0x1002>     
40006f08:	80 a2 00 03 	cmp  %o0, %g3                                  
40006f0c:	02 80 00 0e 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006f10:	82 10 20 11 	mov  0x11, %g1                                 
40006f14:	80 a2 00 03 	cmp  %o0, %g3                                  
40006f18:	08 80 00 3a 	bleu  40007000 <rtems_termios_baud_to_index+0x130>
40006f1c:	80 a2 20 0f 	cmp  %o0, 0xf                                  
40006f20:	86 10 a0 03 	or  %g2, 3, %g3                                
40006f24:	80 a2 00 03 	cmp  %o0, %g3                                  
40006f28:	02 80 00 07 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006f2c:	82 10 20 12 	mov  0x12, %g1                                 
40006f30:	84 10 a0 04 	or  %g2, 4, %g2                                
40006f34:	80 a2 00 02 	cmp  %o0, %g2                                  
40006f38:	02 80 00 03 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006f3c:	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;                          
40006f40:	82 10 3f ff 	mov  -1, %g1                                   
  }                                                                   
                                                                      
  return baud_index;                                                  
}                                                                     
40006f44:	81 c3 e0 08 	retl                                           
40006f48:	90 10 00 01 	mov  %g1, %o0                                  
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
40006f4c:	02 bf ff fe 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006f50:	82 10 20 04 	mov  4, %g1                                    
40006f54:	80 a2 20 04 	cmp  %o0, 4                                    
40006f58:	08 80 00 1d 	bleu  40006fcc <rtems_termios_baud_to_index+0xfc>
40006f5c:	80 a2 20 01 	cmp  %o0, 1                                    
40006f60:	80 a2 20 06 	cmp  %o0, 6                                    
40006f64:	02 bf ff f8 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006f68:	82 10 20 06 	mov  6, %g1                                    
40006f6c:	80 a2 20 06 	cmp  %o0, 6                                    
40006f70:	0a bf ff f5 	bcs  40006f44 <rtems_termios_baud_to_index+0x74>
40006f74:	82 10 20 05 	mov  5, %g1                                    
40006f78:	80 a2 20 07 	cmp  %o0, 7                                    
40006f7c:	02 bf ff f2 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006f80:	82 10 20 07 	mov  7, %g1                                    
40006f84:	80 a2 20 08 	cmp  %o0, 8                                    
40006f88:	02 bf ff ef 	be  40006f44 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40006f8c:	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;                          
40006f90:	10 bf ff ed 	b  40006f44 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40006f94:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
40006f98:	02 bf ff eb 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006f9c:	82 10 20 0b 	mov  0xb, %g1                                  
40006fa0:	80 a2 20 0b 	cmp  %o0, 0xb                                  
40006fa4:	0a bf ff e8 	bcs  40006f44 <rtems_termios_baud_to_index+0x74>
40006fa8:	82 10 20 0a 	mov  0xa, %g1                                  
40006fac:	80 a2 20 0c 	cmp  %o0, 0xc                                  
40006fb0:	02 bf ff e5 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006fb4:	82 10 20 0c 	mov  0xc, %g1                                  
40006fb8:	80 a2 20 0d 	cmp  %o0, 0xd                                  
40006fbc:	02 bf ff e2 	be  40006f44 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40006fc0:	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;                          
40006fc4:	10 bf ff e0 	b  40006f44 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40006fc8:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
40006fcc:	02 bf ff de 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006fd0:	82 10 20 01 	mov  1, %g1                                    
40006fd4:	80 a2 20 01 	cmp  %o0, 1                                    
40006fd8:	0a bf ff db 	bcs  40006f44 <rtems_termios_baud_to_index+0x74>
40006fdc:	82 10 20 00 	clr  %g1                                       
40006fe0:	80 a2 20 02 	cmp  %o0, 2                                    
40006fe4:	02 bf ff d8 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40006fe8:	82 10 20 02 	mov  2, %g1                                    
40006fec:	80 a2 20 03 	cmp  %o0, 3                                    
40006ff0:	02 bf ff d5 	be  40006f44 <rtems_termios_baud_to_index+0x74><== ALWAYS TAKEN
40006ff4:	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;                          
40006ff8:	10 bf ff d3 	b  40006f44 <rtems_termios_baud_to_index+0x74> <== NOT EXECUTED
40006ffc:	82 10 3f ff 	mov  -1, %g1                                   <== NOT EXECUTED
  rtems_termios_baud_t termios_baud                                   
)                                                                     
{                                                                     
  int baud_index;                                                     
                                                                      
  switch (termios_baud) {                                             
40007000:	02 bf ff d1 	be  40006f44 <rtems_termios_baud_to_index+0x74>
40007004:	82 10 20 0f 	mov  0xf, %g1                                  
40007008:	84 10 a0 01 	or  %g2, 1, %g2                                
4000700c:	80 a2 00 02 	cmp  %o0, %g2                                  
40007010:	12 bf ff cc 	bne  40006f40 <rtems_termios_baud_to_index+0x70><== NEVER TAKEN
40007014:	82 10 20 10 	mov  0x10, %g1                                 
40007018:	30 bf ff cb 	b,a   40006f44 <rtems_termios_baud_to_index+0x74>
                                                                      

40006274 <rtems_termios_close>: rtems_interrupt_enable (level); } rtems_status_code rtems_termios_close (void *arg) {
40006274:	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(                                        
40006278:	39 10 00 80 	sethi  %hi(0x40020000), %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;                   
4000627c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
40006280:	d0 07 21 60 	ld  [ %i4 + 0x160 ], %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;                   
40006284:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain(                                        
40006288:	92 10 20 00 	clr  %o1                                       
4000628c:	40 00 08 c0 	call  4000858c <rtems_semaphore_obtain>        
40006290:	94 10 20 00 	clr  %o2                                       
    rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);            
  if (sc != RTEMS_SUCCESSFUL)                                         
40006294:	80 a2 20 00 	cmp  %o0, 0                                    
40006298:	12 80 00 6e 	bne  40006450 <rtems_termios_close+0x1dc>      <== NEVER TAKEN
4000629c:	01 00 00 00 	nop                                            
    rtems_fatal_error_occurred (sc);                                  
  if (--tty->refcount == 0) {                                         
400062a0:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
400062a4:	82 00 7f ff 	add  %g1, -1, %g1                              
400062a8:	80 a0 60 00 	cmp  %g1, 0                                    
400062ac:	12 80 00 39 	bne  40006390 <rtems_termios_close+0x11c>      
400062b0:	c2 27 60 08 	st  %g1, [ %i5 + 8 ]                           
    if (rtems_termios_linesw[tty->t_line].l_close != NULL) {          
400062b4:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
400062b8:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
400062bc:	85 28 a0 05 	sll  %g2, 5, %g2                               
400062c0:	82 10 61 34 	or  %g1, 0x134, %g1                            
400062c4:	82 00 40 02 	add  %g1, %g2, %g1                             
400062c8:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
400062cc:	80 a0 60 00 	cmp  %g1, 0                                    
400062d0:	22 80 00 42 	be,a   400063d8 <rtems_termios_close+0x164>    
400062d4:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
      /*                                                              
       * call discipline-specific close                               
       */                                                             
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
400062d8:	9f c0 40 00 	call  %g1                                      
400062dc:	90 10 00 1d 	mov  %i5, %o0                                  
      }                                                               
      drainOutput (tty);                                              
      rtems_semaphore_release (tty->osem);                            
    }                                                                 
                                                                      
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
400062e0:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
400062e4:	80 a0 60 02 	cmp  %g1, 2                                    
400062e8:	22 80 00 4f 	be,a   40006424 <rtems_termios_close+0x1b0>    <== NEVER TAKEN
400062ec:	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)                                        
400062f0:	c2 07 60 9c 	ld  [ %i5 + 0x9c ], %g1                        
400062f4:	80 a0 60 00 	cmp  %g1, 0                                    
400062f8:	22 80 00 07 	be,a   40006314 <rtems_termios_close+0xa0>     <== ALWAYS TAKEN
400062fc:	c2 07 40 00 	ld  [ %i5 ], %g1                               
       (*tty->device.lastClose)(tty->major, tty->minor, arg);         
40006300:	d0 07 60 0c 	ld  [ %i5 + 0xc ], %o0                         <== NOT EXECUTED
40006304:	d2 07 60 10 	ld  [ %i5 + 0x10 ], %o1                        <== NOT EXECUTED
40006308:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4000630c:	94 10 00 18 	mov  %i0, %o2                                  <== NOT EXECUTED
    if (tty->forw == NULL) {                                          
40006310:	c2 07 40 00 	ld  [ %i5 ], %g1                               <== NOT EXECUTED
40006314:	80 a0 60 00 	cmp  %g1, 0                                    
40006318:	02 80 00 29 	be  400063bc <rtems_termios_close+0x148>       
4000631c:	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;                                    
40006320:	c4 20 60 04 	st  %g2, [ %g1 + 4 ]                           
40006324:	c4 07 60 04 	ld  [ %i5 + 4 ], %g2                           
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
40006328:	80 a0 a0 00 	cmp  %g2, 0                                    
4000632c:	22 80 00 21 	be,a   400063b0 <rtems_termios_close+0x13c>    <== ALWAYS TAKEN
40006330:	05 10 00 80 	sethi  %hi(0x40020000), %g2                    
      rtems_termios_ttyHead = tty->forw;                              
      if ( rtems_termios_ttyHead != NULL ) {                          
        rtems_termios_ttyHead->back = NULL;                           
      }                                                               
    } else {                                                          
      tty->back->forw = tty->forw;                                    
40006334:	c2 20 80 00 	st  %g1, [ %g2 ]                               <== NOT EXECUTED
    }                                                                 
                                                                      
    rtems_semaphore_delete (tty->isem);                               
40006338:	40 00 08 5e 	call  400084b0 <rtems_semaphore_delete>        
4000633c:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
    rtems_semaphore_delete (tty->osem);                               
40006340:	40 00 08 5c 	call  400084b0 <rtems_semaphore_delete>        
40006344:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
    rtems_semaphore_delete (tty->rawOutBuf.Semaphore);                
40006348:	40 00 08 5a 	call  400084b0 <rtems_semaphore_delete>        
4000634c:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        
    if ((tty->device.pollRead == NULL) ||                             
40006350:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
40006354:	80 a0 60 00 	cmp  %g1, 0                                    
40006358:	02 80 00 13 	be  400063a4 <rtems_termios_close+0x130>       
4000635c:	01 00 00 00 	nop                                            
40006360:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40006364:	80 a0 60 02 	cmp  %g1, 2                                    
40006368:	02 80 00 0f 	be  400063a4 <rtems_termios_close+0x130>       
4000636c:	01 00 00 00 	nop                                            
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))    
      rtems_semaphore_delete (tty->rawInBuf.Semaphore);               
    free (tty->rawInBuf.theBuf);                                      
40006370:	7f ff f7 a6 	call  40004208 <free>                          
40006374:	d0 07 60 58 	ld  [ %i5 + 0x58 ], %o0                        
    free (tty->rawOutBuf.theBuf);                                     
40006378:	7f ff f7 a4 	call  40004208 <free>                          
4000637c:	d0 07 60 7c 	ld  [ %i5 + 0x7c ], %o0                        
    free (tty->cbuf);                                                 
40006380:	7f ff f7 a2 	call  40004208 <free>                          
40006384:	d0 07 60 1c 	ld  [ %i5 + 0x1c ], %o0                        
    free (tty);                                                       
40006388:	7f ff f7 a0 	call  40004208 <free>                          
4000638c:	90 10 00 1d 	mov  %i5, %o0                                  
  }                                                                   
  rtems_semaphore_release (rtems_termios_ttyMutex);                   
40006390:	d0 07 21 60 	ld  [ %i4 + 0x160 ], %o0                       
40006394:	40 00 08 cd 	call  400086c8 <rtems_semaphore_release>       
40006398:	b0 10 20 00 	clr  %i0                                       
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
4000639c:	81 c7 e0 08 	ret                                            
400063a0:	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);               
400063a4:	40 00 08 43 	call  400084b0 <rtems_semaphore_delete>        
400063a8:	d0 07 60 68 	ld  [ %i5 + 0x68 ], %o0                        
400063ac:	30 bf ff f1 	b,a   40006370 <rtems_termios_close+0xfc>      
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
      rtems_termios_ttyHead = tty->forw;                              
      if ( rtems_termios_ttyHead != NULL ) {                          
        rtems_termios_ttyHead->back = NULL;                           
400063b0:	c0 20 60 04 	clr  [ %g1 + 4 ]                               
    } else {                                                          
      tty->forw->back = tty->back;                                    
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
      rtems_termios_ttyHead = tty->forw;                              
400063b4:	10 bf ff e1 	b  40006338 <rtems_termios_close+0xc4>         
400063b8:	c2 20 a1 68 	st  %g1, [ %g2 + 0x168 ]                       
        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;                              
400063bc:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
      if ( rtems_termios_ttyTail != NULL ) {                          
400063c0:	80 a0 a0 00 	cmp  %g2, 0                                    
400063c4:	02 80 00 25 	be  40006458 <rtems_termios_close+0x1e4>       <== ALWAYS TAKEN
400063c8:	c4 20 61 64 	st  %g2, [ %g1 + 0x164 ]                       
        rtems_termios_ttyTail->forw = NULL;                           
400063cc:	c0 20 80 00 	clr  [ %g2 ]                                   <== NOT EXECUTED
400063d0:	10 bf ff d9 	b  40006334 <rtems_termios_close+0xc0>         <== NOT EXECUTED
400063d4:	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);
400063d8:	92 10 20 00 	clr  %o1                                       
400063dc:	40 00 08 6c 	call  4000858c <rtems_semaphore_obtain>        
400063e0:	94 10 20 00 	clr  %o2                                       
      if (sc != RTEMS_SUCCESSFUL) {                                   
400063e4:	80 a2 20 00 	cmp  %o0, 0                                    
400063e8:	12 80 00 1a 	bne  40006450 <rtems_termios_close+0x1dc>      <== NEVER TAKEN
400063ec:	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) {           
400063f0:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
400063f4:	80 a0 60 00 	cmp  %g1, 0                                    
400063f8:	02 80 00 04 	be  40006408 <rtems_termios_close+0x194>       
400063fc:	01 00 00 00 	nop                                            
40006400:	7f ff fe 72 	call  40005dc8 <drainOutput.part.0>            
40006404:	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);                            
40006408:	40 00 08 b0 	call  400086c8 <rtems_semaphore_release>       
4000640c:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
    }                                                                 
                                                                      
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
40006410:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40006414:	80 a0 60 02 	cmp  %g1, 2                                    
40006418:	32 bf ff b7 	bne,a   400062f4 <rtems_termios_close+0x80>    
4000641c:	c2 07 60 9c 	ld  [ %i5 + 0x9c ], %g1                        
      /*                                                              
       * send "terminate" to I/O tasks                                
       */                                                             
      sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
40006420:	d0 07 60 c4 	ld  [ %i5 + 0xc4 ], %o0                        
40006424:	40 00 07 21 	call  400080a8 <rtems_event_send>              
40006428:	92 10 20 01 	mov  1, %o1                                    
      if (sc != RTEMS_SUCCESSFUL)                                     
4000642c:	80 a2 20 00 	cmp  %o0, 0                                    
40006430:	12 80 00 08 	bne  40006450 <rtems_termios_close+0x1dc>      <== NEVER TAKEN
40006434:	01 00 00 00 	nop                                            
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
40006438:	d0 07 60 c8 	ld  [ %i5 + 0xc8 ], %o0                        
4000643c:	40 00 07 1b 	call  400080a8 <rtems_event_send>              
40006440:	92 10 20 01 	mov  1, %o1                                    
      if (sc != RTEMS_SUCCESSFUL)                                     
40006444:	80 a2 20 00 	cmp  %o0, 0                                    
40006448:	22 bf ff ab 	be,a   400062f4 <rtems_termios_close+0x80>     <== ALWAYS TAKEN
4000644c:	c2 07 60 9c 	ld  [ %i5 + 0x9c ], %g1                        
        rtems_fatal_error_occurred (sc);                              
40006450:	40 00 0a 34 	call  40008d20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40006454:	01 00 00 00 	nop                                            <== NOT EXECUTED
    } else {                                                          
      tty->forw->back = tty->back;                                    
    }                                                                 
                                                                      
    if (tty->back == NULL) {                                          
      rtems_termios_ttyHead = tty->forw;                              
40006458:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
4000645c:	10 bf ff b7 	b  40006338 <rtems_termios_close+0xc4>         
40006460:	c0 20 61 68 	clr  [ %g1 + 0x168 ]	! 40020168 <rtems_termios_ttyHead>
                                                                      

4000795c <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) {
4000795c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_status_code sc;                                               
                                                                      
  /*                                                                  
   * sum up character count already sent                              
   */                                                                 
  tty->t_dqlen += len;                                                
40007960:	c4 06 20 90 	ld  [ %i0 + 0x90 ], %g2                        
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
40007964:	c2 06 20 b4 	ld  [ %i0 + 0xb4 ], %g1                        
  rtems_status_code sc;                                               
                                                                      
  /*                                                                  
   * sum up character count already sent                              
   */                                                                 
  tty->t_dqlen += len;                                                
40007968:	b2 00 80 19 	add  %g2, %i1, %i1                             
4000796c:	f2 26 20 90 	st  %i1, [ %i0 + 0x90 ]                        
                                                                      
  if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {      
40007970:	80 a0 60 02 	cmp  %g1, 2                                    
40007974:	02 80 00 10 	be  400079b4 <rtems_termios_dequeue_characters+0x58>
40007978:	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 ) {                                      
4000797c:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        
40007980:	80 a0 60 05 	cmp  %g1, 5                                    
40007984:	02 80 00 04 	be  40007994 <rtems_termios_dequeue_characters+0x38>
40007988:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
    }                                                                 
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  return rtems_termios_refill_transmitter(tty);                       
4000798c:	7f ff f8 73 	call  40005b58 <rtems_termios_refill_transmitter>
40007990:	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) {          
40007994:	c2 00 61 e8 	ld  [ %g1 + 0x1e8 ], %g1                       
40007998:	80 a0 60 00 	cmp  %g1, 0                                    
4000799c:	02 80 00 04 	be  400079ac <rtems_termios_dequeue_characters+0x50><== NEVER TAKEN
400079a0:	01 00 00 00 	nop                                            
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
400079a4:	9f c0 40 00 	call  %g1                                      
400079a8:	01 00 00 00 	nop                                            
    }                                                                 
    return 0; /* nothing to output in IRQ... */                       
  }                                                                   
                                                                      
  return rtems_termios_refill_transmitter(tty);                       
}                                                                     
400079ac:	81 c7 e0 08 	ret                                            
400079b0:	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);     
400079b4:	d0 06 20 c8 	ld  [ %i0 + 0xc8 ], %o0                        
400079b8:	40 00 01 bc 	call  400080a8 <rtems_event_send>              
400079bc:	92 10 20 02 	mov  2, %o1                                    
    if (sc != RTEMS_SUCCESSFUL)                                       
400079c0:	80 a2 20 00 	cmp  %o0, 0                                    
400079c4:	02 bf ff fa 	be  400079ac <rtems_termios_dequeue_characters+0x50><== ALWAYS TAKEN
400079c8:	01 00 00 00 	nop                                            
      rtems_fatal_error_occurred (sc);                                
400079cc:	40 00 04 d5 	call  40008d20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
                                                                      

400075b4 <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) {
400075b4:	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) {             
400075b8:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        
400075bc:	37 10 00 7f 	sethi  %hi(0x4001fc00), %i3                    
400075c0:	83 28 60 05 	sll  %g1, 5, %g1                               
400075c4:	b6 16 e1 34 	or  %i3, 0x134, %i3                            
400075c8:	82 06 c0 01 	add  %i3, %g1, %g1                             
400075cc:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
400075d0:	80 a0 60 00 	cmp  %g1, 0                                    
400075d4:	02 80 00 23 	be  40007660 <rtems_termios_enqueue_raw_characters+0xac>
400075d8:	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)
400075dc:	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--) {                                                   
400075e0:	80 a6 a0 00 	cmp  %i2, 0                                    
400075e4:	12 80 00 08 	bne  40007604 <rtems_termios_enqueue_raw_characters+0x50><== ALWAYS TAKEN
400075e8:	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 )) { 
400075ec:	10 80 00 0d 	b  40007620 <rtems_termios_enqueue_raw_characters+0x6c><== NOT EXECUTED
400075f0:	c2 07 20 e4 	ld  [ %i4 + 0xe4 ], %g1                        <== NOT EXECUTED
400075f4:	ba 07 60 01 	inc  %i5                                       
400075f8:	83 28 60 05 	sll  %g1, 5, %g1                               
400075fc:	82 06 c0 01 	add  %i3, %g1, %g1                             
40007600:	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);                
40007604:	d0 4e 40 1d 	ldsb  [ %i1 + %i5 ], %o0                       
40007608:	9f c0 40 00 	call  %g1                                      
4000760c:	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--) {                                                   
40007610:	80 a7 40 18 	cmp  %i5, %i0                                  
40007614:	32 bf ff f8 	bne,a   400075f4 <rtems_termios_enqueue_raw_characters+0x40>
40007618:	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 )) { 
4000761c:	c2 07 20 e4 	ld  [ %i4 + 0xe4 ], %g1                        
40007620:	80 a0 60 00 	cmp  %g1, 0                                    
40007624:	12 80 00 0d 	bne  40007658 <rtems_termios_enqueue_raw_characters+0xa4><== NEVER TAKEN
40007628:	01 00 00 00 	nop                                            
4000762c:	c2 07 20 dc 	ld  [ %i4 + 0xdc ], %g1                        
40007630:	80 a0 60 00 	cmp  %g1, 0                                    
40007634:	02 80 00 07 	be  40007650 <rtems_termios_enqueue_raw_characters+0x9c>
40007638:	b0 10 20 00 	clr  %i0                                       
      (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);     
4000763c:	d2 07 20 e0 	ld  [ %i4 + 0xe0 ], %o1                        
40007640:	9f c0 40 00 	call  %g1                                      
40007644:	90 07 20 30 	add  %i4, 0x30, %o0                            
      tty->tty_rcvwakeup = 1;                                         
40007648:	82 10 20 01 	mov  1, %g1                                    
4000764c:	c2 27 20 e4 	st  %g1, [ %i4 + 0xe4 ]                        
40007650:	81 c7 e0 08 	ret                                            
40007654:	81 e8 00 00 	restore                                        
        }                                                             
    return 0;                                                         
40007658:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000765c:	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)
40007660:	b4 06 40 1a 	add  %i1, %i2, %i2                             
40007664:	a0 10 20 00 	clr  %l0                                       
40007668:	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); 
4000766c:	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);              
40007670:	a4 07 20 4a 	add  %i4, 0x4a, %l2                            
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
40007674:	80 a6 40 1a 	cmp  %i1, %i2                                  
40007678:	22 80 00 28 	be,a   40007718 <rtems_termios_enqueue_raw_characters+0x164>
4000767c:	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) {                                  
40007680:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
    c = *buf++;                                                       
40007684:	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) {                                  
40007688:	80 88 62 00 	btst  0x200, %g1                               
4000768c:	02 80 00 0b 	be  400076b8 <rtems_termios_enqueue_raw_characters+0x104>
40007690:	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]) {                            
40007694:	c4 0f 20 4a 	ldub  [ %i4 + 0x4a ], %g2                      
40007698:	83 2f 60 18 	sll  %i5, 0x18, %g1                            
4000769c:	83 38 60 18 	sra  %g1, 0x18, %g1                            
400076a0:	80 a0 40 02 	cmp  %g1, %g2                                  
400076a4:	02 80 00 5c 	be  40007814 <rtems_termios_enqueue_raw_characters+0x260>
400076a8:	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]) {                      
400076ac:	80 a0 40 02 	cmp  %g1, %g2                                  
400076b0:	02 80 00 61 	be  40007834 <rtems_termios_enqueue_raw_characters+0x280><== NEVER TAKEN
400076b4:	01 00 00 00 	nop                                            
        /* restart output  */                                         
        tty->flow_ctrl &= ~FL_ORCVXOF;                                
        flow_rcv = true;                                              
      }                                                               
    }                                                                 
    if (flow_rcv) {                                                   
400076b8:	80 8c 20 ff 	btst  0xff, %l0                                
400076bc:	02 80 00 1d 	be  40007730 <rtems_termios_enqueue_raw_characters+0x17c><== ALWAYS TAKEN
400076c0:	01 00 00 00 	nop                                            
      /* restart output according to FL_ORCVXOF flag */               
      if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {   
400076c4:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        
400076c8:	82 08 60 30 	and  %g1, 0x30, %g1                            
400076cc:	80 a0 60 20 	cmp  %g1, 0x20                                 
400076d0:	12 bf ff ea 	bne  40007678 <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
400076d4:	80 a6 40 1a 	cmp  %i1, %i2                                  
        /* disable interrupts    */                                   
        rtems_interrupt_disable(level);                               
400076d8:	7f ff eb 7e 	call  400024d0 <sparc_disable_interrupts>      <== NOT EXECUTED
400076dc:	01 00 00 00 	nop                                            <== NOT EXECUTED
400076e0:	ba 10 00 08 	mov  %o0, %i5                                  <== NOT EXECUTED
        tty->flow_ctrl &= ~FL_OSTOP;                                  
400076e4:	c4 07 20 b8 	ld  [ %i4 + 0xb8 ], %g2                        <== NOT EXECUTED
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
400076e8:	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;                                  
400076ec:	84 08 bf df 	and  %g2, -33, %g2                             <== NOT EXECUTED
400076f0:	c4 27 20 b8 	st  %g2, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
        /* check for chars in output buffer (or rob_state?) */        
        if (tty->rawOutBufState != rob_idle) {                        
400076f4:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400076f8:	12 80 00 57 	bne  40007854 <rtems_termios_enqueue_raw_characters+0x2a0><== NOT EXECUTED
400076fc:	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);                                
40007700:	7f ff eb 78 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40007704:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
      tty->tty_rcvwakeup = 1;                                         
        }                                                             
    return 0;                                                         
  }                                                                   
                                                                      
  while (len--) {                                                     
40007708:	80 a6 40 1a 	cmp  %i1, %i2                                  <== NOT EXECUTED
4000770c:	12 bf ff dd 	bne  40007680 <rtems_termios_enqueue_raw_characters+0xcc><== NOT EXECUTED
40007710:	01 00 00 00 	nop                                            <== NOT EXECUTED
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  tty->rawInBufDropped += dropped;                                    
40007714:	c2 07 20 78 	ld  [ %i4 + 0x78 ], %g1                        <== NOT EXECUTED
  rtems_semaphore_release (tty->rawInBuf.Semaphore);                  
40007718:	d0 07 20 68 	ld  [ %i4 + 0x68 ], %o0                        
        }                                                             
      }                                                               
    }                                                                 
  }                                                                   
                                                                      
  tty->rawInBufDropped += dropped;                                    
4000771c:	82 00 40 18 	add  %g1, %i0, %g1                             
  rtems_semaphore_release (tty->rawInBuf.Semaphore);                  
40007720:	40 00 03 ea 	call  400086c8 <rtems_semaphore_release>       
40007724:	c2 27 20 78 	st  %g1, [ %i4 + 0x78 ]                        
  return dropped;                                                     
40007728:	81 c7 e0 08 	ret                                            
4000772c:	81 e8 00 00 	restore                                        
        }                                                             
        /* reenable interrupts */                                     
        rtems_interrupt_enable(level);                                
      }                                                               
    } else {                                                          
      newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;        
40007730:	d0 07 20 60 	ld  [ %i4 + 0x60 ], %o0                        
40007734:	d2 07 20 64 	ld  [ %i4 + 0x64 ], %o1                        
40007738:	40 00 49 7b 	call  40019d24 <.urem>                         
4000773c:	90 02 20 01 	inc  %o0                                       
      /* if chars_in_buffer > highwater                */             
      rtems_interrupt_disable(level);                                 
40007740:	7f ff eb 64 	call  400024d0 <sparc_disable_interrupts>      
40007744:	b6 10 00 08 	mov  %o0, %i3                                  
40007748:	a6 10 00 08 	mov  %o0, %l3                                  
      if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)       
4000774c:	c2 07 20 5c 	ld  [ %i4 + 0x5c ], %g1                        
40007750:	d0 07 20 64 	ld  [ %i4 + 0x64 ], %o0                        
            % tty->rawInBuf.Size) > tty->highwater) &&                
40007754:	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)       
40007758:	90 22 00 01 	sub  %o0, %g1, %o0                             
            % tty->rawInBuf.Size) > tty->highwater) &&                
4000775c:	40 00 49 72 	call  40019d24 <.urem>                         
40007760:	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)       
40007764:	c2 07 20 c0 	ld  [ %i4 + 0xc0 ], %g1                        
40007768:	80 a2 00 01 	cmp  %o0, %g1                                  
4000776c:	08 80 00 13 	bleu  400077b8 <rtems_termios_enqueue_raw_characters+0x204><== ALWAYS TAKEN
40007770:	01 00 00 00 	nop                                            
            % tty->rawInBuf.Size) > tty->highwater) &&                
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
40007774:	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) &&                
40007778:	80 88 60 01 	btst  1, %g1                                   <== NOT EXECUTED
4000777c:	12 80 00 0f 	bne  400077b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40007780:	01 00 00 00 	nop                                            <== NOT EXECUTED
          !(tty->flow_ctrl & FL_IREQXOF)) {                           
        /* incoming data stream should be stopped */                  
        tty->flow_ctrl |= FL_IREQXOF;                                 
40007784:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        <== NOT EXECUTED
40007788:	82 10 60 01 	or  %g1, 1, %g1                                <== NOT EXECUTED
4000778c:	c2 27 20 b8 	st  %g1, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
        if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))                
40007790:	c2 07 20 b8 	ld  [ %i4 + 0xb8 ], %g1                        <== NOT EXECUTED
40007794:	82 08 64 02 	and  %g1, 0x402, %g1                           <== NOT EXECUTED
40007798:	80 a0 64 00 	cmp  %g1, 0x400                                <== NOT EXECUTED
            ==                (FL_MDXOF             ) ) {             
          if ((tty->flow_ctrl & FL_OSTOP) ||                          
4000779c:	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))                
400077a0:	02 80 00 35 	be  40007874 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
400077a4:	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) ) {
400077a8:	82 08 61 04 	and  %g1, 0x104, %g1                           <== NOT EXECUTED
400077ac:	80 a0 61 00 	cmp  %g1, 0x100                                <== NOT EXECUTED
400077b0:	02 80 00 40 	be  400078b0 <rtems_termios_enqueue_raw_characters+0x2fc><== NOT EXECUTED
400077b4:	01 00 00 00 	nop                                            <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* reenable interrupts */                                       
      rtems_interrupt_enable(level);                                  
400077b8:	7f ff eb 4a 	call  400024e0 <sparc_enable_interrupts>       
400077bc:	90 10 00 13 	mov  %l3, %o0                                  
                                                                      
      if (newTail == tty->rawInBuf.Head) {                            
400077c0:	c2 07 20 5c 	ld  [ %i4 + 0x5c ], %g1                        
400077c4:	80 a0 40 1b 	cmp  %g1, %i3                                  
400077c8:	22 bf ff ab 	be,a   40007674 <rtems_termios_enqueue_raw_characters+0xc0><== NEVER TAKEN
400077cc:	b0 06 20 01 	inc  %i0                                       <== NOT EXECUTED
        dropped++;                                                    
      } else {                                                        
        tty->rawInBuf.theBuf[newTail] = c;                            
400077d0:	c2 07 20 58 	ld  [ %i4 + 0x58 ], %g1                        
400077d4:	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 )) {
400077d8:	c2 07 20 e4 	ld  [ %i4 + 0xe4 ], %g1                        
                                                                      
      if (newTail == tty->rawInBuf.Head) {                            
        dropped++;                                                    
      } else {                                                        
        tty->rawInBuf.theBuf[newTail] = c;                            
        tty->rawInBuf.Tail = newTail;                                 
400077dc:	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 )) {
400077e0:	80 a0 60 00 	cmp  %g1, 0                                    
400077e4:	12 bf ff a5 	bne  40007678 <rtems_termios_enqueue_raw_characters+0xc4><== NEVER TAKEN
400077e8:	80 a6 40 1a 	cmp  %i1, %i2                                  
400077ec:	c2 07 20 dc 	ld  [ %i4 + 0xdc ], %g1                        
400077f0:	80 a0 60 00 	cmp  %g1, 0                                    
400077f4:	02 bf ff a1 	be  40007678 <rtems_termios_enqueue_raw_characters+0xc4><== ALWAYS TAKEN
400077f8:	80 a6 40 1a 	cmp  %i1, %i2                                  
          (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 
400077fc:	d2 07 20 e0 	ld  [ %i4 + 0xe0 ], %o1                        <== NOT EXECUTED
40007800:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40007804:	90 10 00 11 	mov  %l1, %o0                                  <== NOT EXECUTED
          tty->tty_rcvwakeup = 1;                                     
40007808:	82 10 20 01 	mov  1, %g1                                    <== NOT EXECUTED
4000780c:	10 bf ff 9a 	b  40007674 <rtems_termios_enqueue_raw_characters+0xc0><== NOT EXECUTED
40007810:	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]) {                         
40007814:	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;               
40007818:	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]) {                         
4000781c:	22 80 00 0b 	be,a   40007848 <rtems_termios_enqueue_raw_characters+0x294><== NEVER TAKEN
40007820:	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;                               
40007824:	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)
40007828:	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;                               
4000782c:	c2 27 20 b8 	st  %g1, [ %i4 + 0xb8 ]                        
40007830:	30 bf ff a5 	b,a   400076c4 <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;                                
40007834:	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)
40007838:	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;                                
4000783c:	82 08 7f ef 	and  %g1, -17, %g1                             <== NOT EXECUTED
40007840:	c2 27 20 b8 	st  %g1, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
40007844:	30 bf ff a0 	b,a   400076c4 <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)
40007848:	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;               
4000784c:	c2 27 20 b8 	st  %g1, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
40007850:	30 bf ff 9d 	b,a   400076c4 <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);
40007854:	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)(                                       
40007858:	d2 07 20 7c 	ld  [ %i4 + 0x7c ], %o1                        <== NOT EXECUTED
4000785c:	c2 07 20 a4 	ld  [ %i4 + 0xa4 ], %g1                        <== NOT EXECUTED
40007860:	d0 07 20 10 	ld  [ %i4 + 0x10 ], %o0                        <== NOT EXECUTED
40007864:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
40007868:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4000786c:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
40007870:	30 bf ff a4 	b,a   40007700 <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) ||                          
40007874:	12 80 00 06 	bne  4000788c <rtems_termios_enqueue_raw_characters+0x2d8><== NOT EXECUTED
40007878:	01 00 00 00 	nop                                            <== NOT EXECUTED
4000787c:	c2 07 20 94 	ld  [ %i4 + 0x94 ], %g1                        <== NOT EXECUTED
40007880:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
40007884:	12 bf ff cd 	bne  400077b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
40007888:	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;                             
4000788c:	c4 07 20 b8 	ld  [ %i4 + 0xb8 ], %g2                        <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
40007890:	c2 07 20 a4 	ld  [ %i4 + 0xa4 ], %g1                        <== NOT EXECUTED
40007894:	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;                             
40007898:	84 10 a0 02 	or  %g2, 2, %g2                                <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
4000789c:	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;                             
400078a0:	c4 27 20 b8 	st  %g2, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
            (*tty->device.write)(tty->minor,                          
400078a4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400078a8:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
400078ac:	30 bf ff c3 	b,a   400077b8 <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;                               
400078b0:	c4 07 20 b8 	ld  [ %i4 + 0xb8 ], %g2                        <== NOT EXECUTED
          /* deactivate RTS line */                                   
          if (tty->device.stopRemoteTx != NULL) {                     
400078b4:	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;                               
400078b8:	84 10 a0 04 	or  %g2, 4, %g2                                <== NOT EXECUTED
400078bc:	c4 27 20 b8 	st  %g2, [ %i4 + 0xb8 ]                        <== NOT EXECUTED
          /* deactivate RTS line */                                   
          if (tty->device.stopRemoteTx != NULL) {                     
400078c0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400078c4:	02 bf ff bd 	be  400077b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
400078c8:	01 00 00 00 	nop                                            <== NOT EXECUTED
            tty->device.stopRemoteTx(tty->minor);                     
400078cc:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400078d0:	d0 07 20 10 	ld  [ %i4 + 0x10 ], %o0                        <== NOT EXECUTED
400078d4:	30 bf ff b9 	b,a   400077b8 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
                                                                      

40006484 <rtems_termios_ioctl>: } } rtems_status_code rtems_termios_ioctl (void *arg) {
40006484:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_ioctl_args_t *args = arg;                               
  struct rtems_termios_tty *tty = args->iop->data1;                   
40006488:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  struct ttywakeup         *wakeup = (struct ttywakeup *)args->buffer;
4000648c:	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;                   
40006490:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  }                                                                   
}                                                                     
                                                                      
rtems_status_code                                                     
rtems_termios_ioctl (void *arg)                                       
{                                                                     
40006494:	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);
40006498:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
4000649c:	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;                                             
400064a0:	c0 26 20 0c 	clr  [ %i0 + 0xc ]                             
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400064a4:	40 00 08 3a 	call  4000858c <rtems_semaphore_obtain>        
400064a8:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL) {                                       
400064ac:	b0 92 20 00 	orcc  %o0, 0, %i0                              
400064b0:	12 80 00 23 	bne  4000653c <rtems_termios_ioctl+0xb8>       <== NEVER TAKEN
400064b4:	01 00 00 00 	nop                                            
    return sc;                                                        
  }                                                                   
  switch (args->command) {                                            
400064b8:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
400064bc:	80 a0 60 05 	cmp  %g1, 5                                    
400064c0:	22 80 00 1a 	be,a   40006528 <rtems_termios_ioctl+0xa4>     
400064c4:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
400064c8:	18 80 00 1f 	bgu  40006544 <rtems_termios_ioctl+0xc0>       
400064cc:	05 10 01 19 	sethi  %hi(0x40046400), %g2                    
400064d0:	80 a0 60 02 	cmp  %g1, 2                                    
400064d4:	22 80 00 2f 	be,a   40006590 <rtems_termios_ioctl+0x10c>    
400064d8:	d2 07 20 08 	ld  [ %i4 + 8 ], %o1                           
400064dc:	18 80 00 bf 	bgu  400067d8 <rtems_termios_ioctl+0x354>      
400064e0:	80 a0 60 03 	cmp  %g1, 3                                    
400064e4:	80 a0 60 01 	cmp  %g1, 1                                    
400064e8:	22 80 00 d0 	be,a   40006828 <rtems_termios_ioctl+0x3a4>    <== ALWAYS TAKEN
400064ec:	d0 07 20 08 	ld  [ %i4 + 8 ], %o0                           
  default:                                                            
    if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {          
400064f0:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        <== NOT EXECUTED
400064f4:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
400064f8:	85 28 a0 05 	sll  %g2, 5, %g2                               
400064fc:	82 10 61 34 	or  %g1, 0x134, %g1                            
40006500:	82 00 40 02 	add  %g1, %g2, %g1                             
40006504:	c2 00 60 18 	ld  [ %g1 + 0x18 ], %g1                        
40006508:	80 a0 60 00 	cmp  %g1, 0                                    
4000650c:	02 80 00 0a 	be  40006534 <rtems_termios_ioctl+0xb0>        
40006510:	b0 10 20 0a 	mov  0xa, %i0                                  
      sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);       
40006514:	90 10 00 1d 	mov  %i5, %o0                                  
40006518:	9f c0 40 00 	call  %g1                                      
4000651c:	92 10 00 1c 	mov  %i4, %o1                                  
40006520:	10 80 00 05 	b  40006534 <rtems_termios_ioctl+0xb0>         
40006524:	b0 10 00 08 	mov  %o0, %i0                                  
        break;                                                        
    }                                                                 
    break;                                                            
                                                                      
  case RTEMS_IO_SNDWAKEUP:                                            
    tty->tty_snd = *wakeup;                                           
40006528:	c2 27 60 d4 	st  %g1, [ %i5 + 0xd4 ]                        
4000652c:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
40006530:	c2 27 60 d8 	st  %g1, [ %i5 + 0xd8 ]                        
      *(int *)args->buffer = tty->ccount - tty->cindex + rawnc;       
    }                                                                 
    break;                                                            
  }                                                                   
                                                                      
  rtems_semaphore_release (tty->osem);                                
40006534:	40 00 08 65 	call  400086c8 <rtems_semaphore_release>       
40006538:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
  return sc;                                                          
}                                                                     
4000653c:	81 c7 e0 08 	ret                                            
40006540:	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) {                                            
40006544:	84 10 a2 7f 	or  %g2, 0x27f, %g2                            
40006548:	80 a0 40 02 	cmp  %g1, %g2                                  
4000654c:	02 80 00 77 	be  40006728 <rtems_termios_ioctl+0x2a4>       <== NEVER TAKEN
40006550:	01 00 00 00 	nop                                            
40006554:	38 80 00 81 	bgu,a   40006758 <rtems_termios_ioctl+0x2d4>   
40006558:	05 10 01 1d 	sethi  %hi(0x40047400), %g2                    
4000655c:	80 a0 60 06 	cmp  %g1, 6                                    
40006560:	32 bf ff e5 	bne,a   400064f4 <rtems_termios_ioctl+0x70>    
40006564:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
  case RTEMS_IO_TCDRAIN:                                              
    drainOutput (tty);                                                
    break;                                                            
                                                                      
  case RTEMS_IO_TCFLUSH:                                              
    switch ((intptr_t) args->buffer) {                                
40006568:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
4000656c:	80 a0 60 01 	cmp  %g1, 1                                    
40006570:	02 80 00 c3 	be  4000687c <rtems_termios_ioctl+0x3f8>       
40006574:	80 a0 60 02 	cmp  %g1, 2                                    
40006578:	02 80 00 d1 	be  400068bc <rtems_termios_ioctl+0x438>       
4000657c:	80 a0 60 00 	cmp  %g1, 0                                    
40006580:	02 80 00 d6 	be  400068d8 <rtems_termios_ioctl+0x454>       
40006584:	01 00 00 00 	nop                                            
      case TCIOFLUSH:                                                 
        flushOutput (tty);                                            
        flushInput (tty);                                             
        break;                                                        
      default:                                                        
        sc = RTEMS_INVALID_NAME;                                      
40006588:	10 bf ff eb 	b  40006534 <rtems_termios_ioctl+0xb0>         
4000658c:	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;                   
40006590:	94 10 20 24 	mov  0x24, %o2                                 
40006594:	b8 07 60 30 	add  %i5, 0x30, %i4                            
40006598:	40 00 2b 3b 	call  40011284 <memcpy>                        
4000659c:	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) &&                                 
400065a0:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
400065a4:	80 88 62 00 	btst  0x200, %g1                               
400065a8:	02 80 00 19 	be  4000660c <rtems_termios_ioctl+0x188>       
400065ac:	01 00 00 00 	nop                                            
      !(tty->termios.c_iflag & IXON)) {                               
400065b0:	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) &&                                 
400065b4:	80 88 64 00 	btst  0x400, %g1                               
400065b8:	12 80 00 15 	bne  4000660c <rtems_termios_ioctl+0x188>      
400065bc:	01 00 00 00 	nop                                            
      !(tty->termios.c_iflag & IXON)) {                               
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);                       
400065c0:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
400065c4:	82 08 7d ef 	and  %g1, -529, %g1                            
400065c8:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        
                                                                      
    /* has output been stopped due to received XOFF? */               
    if (tty->flow_ctrl & FL_OSTOP) {                                  
400065cc:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
400065d0:	80 88 60 20 	btst  0x20, %g1                                
400065d4:	02 80 00 0e 	be  4000660c <rtems_termios_ioctl+0x188>       <== ALWAYS TAKEN
400065d8:	01 00 00 00 	nop                                            
      /* disable interrupts    */                                     
      rtems_interrupt_disable(level);                                 
400065dc:	7f ff ef bd 	call  400024d0 <sparc_disable_interrupts>      <== NOT EXECUTED
400065e0:	01 00 00 00 	nop                                            <== NOT EXECUTED
400065e4:	b6 10 00 08 	mov  %o0, %i3                                  <== NOT EXECUTED
      tty->flow_ctrl &= ~FL_OSTOP;                                    
400065e8:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
400065ec:	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;                                    
400065f0:	84 08 bf df 	and  %g2, -33, %g2                             <== NOT EXECUTED
400065f4:	c4 27 60 b8 	st  %g2, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
      /* check for chars in output buffer (or rob_state?) */          
      if (tty->rawOutBufState != rob_idle) {                          
400065f8:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400065fc:	12 80 00 c4 	bne  4000690c <rtems_termios_ioctl+0x488>      <== NOT EXECUTED
40006600:	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);                                  
40006604:	7f ff ef b7 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40006608:	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)) {
4000660c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40006610:	80 88 64 00 	btst  0x400, %g1                               
40006614:	02 80 00 0d 	be  40006648 <rtems_termios_ioctl+0x1c4>       
40006618:	01 00 00 00 	nop                                            
4000661c:	c4 07 60 30 	ld  [ %i5 + 0x30 ], %g2                        
40006620:	03 00 00 04 	sethi  %hi(0x1000), %g1                        
40006624:	80 88 80 01 	btst  %g2, %g1                                 
40006628:	12 80 00 08 	bne  40006648 <rtems_termios_ioctl+0x1c4>      <== NEVER TAKEN
4000662c:	01 00 00 00 	nop                                            
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDXOF);                                    
40006630:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40006634:	82 08 7b ff 	and  %g1, -1025, %g1                           
40006638:	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);                                  
4000663c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40006640:	82 08 7f fd 	and  %g1, -3, %g1                              
40006644:	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)) {
40006648:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
4000664c:	80 88 61 00 	btst  0x100, %g1                               
40006650:	02 80 00 16 	be  400066a8 <rtems_termios_ioctl+0x224>       <== ALWAYS TAKEN
40006654:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        
40006658:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000665c:	06 80 00 93 	bl  400068a8 <rtems_termios_ioctl+0x424>       <== NOT EXECUTED
40006660:	01 00 00 00 	nop                                            <== NOT EXECUTED
    /* clear related flags in flow_ctrl */                            
    tty->flow_ctrl &= ~(FL_MDRTS);                                    
40006664:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
40006668:	84 08 be ff 	and  %g2, -257, %g2                            <== NOT EXECUTED
4000666c:	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)) {
40006670:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
40006674:	80 88 a0 04 	btst  4, %g2                                   <== NOT EXECUTED
40006678:	02 80 00 09 	be  4000669c <rtems_termios_ioctl+0x218>       <== NOT EXECUTED
4000667c:	01 00 00 00 	nop                                            <== NOT EXECUTED
40006680:	c4 07 60 b0 	ld  [ %i5 + 0xb0 ], %g2                        <== NOT EXECUTED
40006684:	80 a0 a0 00 	cmp  %g2, 0                                    <== NOT EXECUTED
40006688:	02 80 00 05 	be  4000669c <rtems_termios_ioctl+0x218>       <== NOT EXECUTED
4000668c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      tty->device.startRemoteTx(tty->minor);                          
40006690:	9f c0 80 00 	call  %g2                                      <== NOT EXECUTED
40006694:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
40006698:	c2 07 60 38 	ld  [ %i5 + 0x38 ], %g1                        <== NOT EXECUTED
    }                                                                 
    tty->flow_ctrl &= ~(FL_IRTSOFF);                                  
4000669c:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
400066a0:	84 08 bf fb 	and  %g2, -5, %g2                              <== NOT EXECUTED
400066a4:	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) {                               
400066a8:	80 a0 60 00 	cmp  %g1, 0                                    
400066ac:	06 80 00 7f 	bl  400068a8 <rtems_termios_ioctl+0x424>       <== NEVER TAKEN
400066b0:	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) {                                 
400066b4:	c2 07 60 30 	ld  [ %i5 + 0x30 ], %g1                        
400066b8:	05 00 00 04 	sethi  %hi(0x1000), %g2                        
400066bc:	80 88 40 02 	btst  %g1, %g2                                 
400066c0:	02 80 00 06 	be  400066d8 <rtems_termios_ioctl+0x254>       
400066c4:	80 88 64 00 	btst  0x400, %g1                               
    tty->flow_ctrl |= FL_MDXOF;                                       
400066c8:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        
400066cc:	84 10 a4 00 	or  %g2, 0x400, %g2                            
400066d0:	c4 27 60 b8 	st  %g2, [ %i5 + 0xb8 ]                        
  }                                                                   
  /* check for outgoing XON/XOF flow control switched on */           
  if (tty->termios.c_iflag & IXON) {                                  
400066d4:	80 88 64 00 	btst  0x400, %g1                               
400066d8:	22 80 00 06 	be,a   400066f0 <rtems_termios_ioctl+0x26c>    
400066dc:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
    tty->flow_ctrl |= FL_MDXON;                                       
400066e0:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
400066e4:	82 10 62 00 	or  %g1, 0x200, %g1                            
400066e8:	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) {                              
400066ec:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
400066f0:	80 88 60 02 	btst  2, %g1                                   
400066f4:	02 80 00 51 	be  40006838 <rtems_termios_ioctl+0x3b4>       
400066f8:	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;                 
400066fc:	c0 27 60 6c 	clr  [ %i5 + 0x6c ]                            
          tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;           
40006700:	c0 27 60 70 	clr  [ %i5 + 0x70 ]                            
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
40006704:	c0 27 60 74 	clr  [ %i5 + 0x74 ]                            
        } else {                                                      
          tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;              
        }                                                             
      }                                                               
    }                                                                 
    if (tty->device.setAttributes)                                    
40006708:	c2 07 60 a8 	ld  [ %i5 + 0xa8 ], %g1                        
4000670c:	80 a0 60 00 	cmp  %g1, 0                                    
40006710:	02 bf ff 89 	be  40006534 <rtems_termios_ioctl+0xb0>        <== NEVER TAKEN
40006714:	01 00 00 00 	nop                                            
      (*tty->device.setAttributes)(tty->minor, &tty->termios);        
40006718:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
4000671c:	9f c0 40 00 	call  %g1                                      
40006720:	92 10 00 1c 	mov  %i4, %o1                                  
40006724:	30 bf ff 84 	b,a   40006534 <rtems_termios_ioctl+0xb0>      
  case TIOCGETD:                                                      
    *(int*)(args->buffer)=tty->t_line;                                
    break;                                                            
#endif                                                                
   case FIONREAD: {                                                   
      int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;            
40006728:	c4 07 60 60 	ld  [ %i5 + 0x60 ], %g2                        <== NOT EXECUTED
4000672c:	c2 07 60 5c 	ld  [ %i5 + 0x5c ], %g1                        <== NOT EXECUTED
      if ( rawnc < 0 )                                                
40006730:	82 a0 80 01 	subcc  %g2, %g1, %g1                           <== NOT EXECUTED
40006734:	0c 80 00 5a 	bneg  4000689c <rtems_termios_ioctl+0x418>     <== NOT EXECUTED
40006738:	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;       
4000673c:	c8 07 60 20 	ld  [ %i5 + 0x20 ], %g4                        <== NOT EXECUTED
40006740:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        <== NOT EXECUTED
40006744:	c6 07 20 08 	ld  [ %i4 + 8 ], %g3                           <== NOT EXECUTED
40006748:	84 21 00 02 	sub  %g4, %g2, %g2                             <== NOT EXECUTED
4000674c:	82 00 80 01 	add  %g2, %g1, %g1                             <== NOT EXECUTED
    }                                                                 
    break;                                                            
40006750:	10 bf ff 79 	b  40006534 <rtems_termios_ioctl+0xb0>         <== NOT EXECUTED
40006754:	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) {                                            
40006758:	84 10 a0 1a 	or  %g2, 0x1a, %g2                             
4000675c:	80 a0 40 02 	cmp  %g1, %g2                                  
40006760:	02 80 00 2e 	be  40006818 <rtems_termios_ioctl+0x394>       
40006764:	05 20 01 1d 	sethi  %hi(0x80047400), %g2                    
40006768:	84 10 a0 1b 	or  %g2, 0x1b, %g2	! 8004741b <LEON_REG+0x4741b>
4000676c:	80 a0 40 02 	cmp  %g1, %g2                                  
40006770:	32 bf ff 61 	bne,a   400064f4 <rtems_termios_ioctl+0x70>    <== NEVER TAKEN
40006774:	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) {          
40006778:	c2 07 60 cc 	ld  [ %i5 + 0xcc ], %g1                        
4000677c:	37 10 00 7f 	sethi  %hi(0x4001fc00), %i3                    
40006780:	83 28 60 05 	sll  %g1, 5, %g1                               
40006784:	b6 16 e1 34 	or  %i3, 0x134, %i3                            
40006788:	82 06 c0 01 	add  %i3, %g1, %g1                             
4000678c:	c2 00 60 04 	ld  [ %g1 + 4 ], %g1                           
40006790:	80 a0 60 00 	cmp  %g1, 0                                    
40006794:	22 80 00 06 	be,a   400067ac <rtems_termios_ioctl+0x328>    
40006798:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
      sc = rtems_termios_linesw[tty->t_line].l_close(tty);            
4000679c:	9f c0 40 00 	call  %g1                                      
400067a0:	90 10 00 1d 	mov  %i5, %o0                                  
400067a4:	b0 10 00 08 	mov  %o0, %i0                                  
    }                                                                 
    tty->t_line=*(int*)(args->buffer);                                
400067a8:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
400067ac:	c2 00 40 00 	ld  [ %g1 ], %g1                               
    tty->t_sc = NULL; /* ensure that no more valid data */            
400067b0:	c0 27 60 d0 	clr  [ %i5 + 0xd0 ]                            
    /*                                                                
     * open new line discipline                                       
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_open != NULL) {           
400067b4:	85 28 60 05 	sll  %g1, 5, %g2                               
400067b8:	c4 06 c0 02 	ld  [ %i3 + %g2 ], %g2                         
400067bc:	80 a0 a0 00 	cmp  %g2, 0                                    
400067c0:	02 bf ff 5d 	be  40006534 <rtems_termios_ioctl+0xb0>        
400067c4:	c2 27 60 cc 	st  %g1, [ %i5 + 0xcc ]                        
      sc = rtems_termios_linesw[tty->t_line].l_open(tty);             
400067c8:	9f c0 80 00 	call  %g2                                      
400067cc:	90 10 00 1d 	mov  %i5, %o0                                  
400067d0:	10 bf ff 59 	b  40006534 <rtems_termios_ioctl+0xb0>         
400067d4:	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) {                                            
400067d8:	02 80 00 09 	be  400067fc <rtems_termios_ioctl+0x378>       
400067dc:	80 a0 60 04 	cmp  %g1, 4                                    
400067e0:	32 bf ff 45 	bne,a   400064f4 <rtems_termios_ioctl+0x70>    <== NEVER TAKEN
400067e4:	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;                                           
400067e8:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
400067ec:	c2 27 60 dc 	st  %g1, [ %i5 + 0xdc ]                        
400067f0:	c2 06 e0 04 	ld  [ %i3 + 4 ], %g1                           
    break;                                                            
400067f4:	10 bf ff 50 	b  40006534 <rtems_termios_ioctl+0xb0>         
400067f8:	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) {           
400067fc:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40006800:	80 a0 60 00 	cmp  %g1, 0                                    
40006804:	02 bf ff 4c 	be  40006534 <rtems_termios_ioctl+0xb0>        <== ALWAYS TAKEN
40006808:	01 00 00 00 	nop                                            
4000680c:	7f ff fd 6f 	call  40005dc8 <drainOutput.part.0>            <== NOT EXECUTED
40006810:	90 10 00 1d 	mov  %i5, %o0                                  <== NOT EXECUTED
40006814:	30 bf ff 48 	b,a   40006534 <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;                                
40006818:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
4000681c:	c2 07 20 08 	ld  [ %i4 + 8 ], %g1                           
    break;                                                            
40006820:	10 bf ff 45 	b  40006534 <rtems_termios_ioctl+0xb0>         
40006824:	c4 20 40 00 	st  %g2, [ %g1 ]                               
      sc = RTEMS_INVALID_NUMBER;                                      
    }                                                                 
    break;                                                            
                                                                      
  case RTEMS_IO_GET_ATTRIBUTES:                                       
    *(struct termios *)args->buffer = tty->termios;                   
40006828:	92 07 60 30 	add  %i5, 0x30, %o1                            
4000682c:	40 00 2a 96 	call  40011284 <memcpy>                        
40006830:	94 10 20 24 	mov  0x24, %o2                                 
    break;                                                            
40006834:	30 bf ff 40 	b,a   40006534 <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;          
40006838:	40 00 05 8d 	call  40007e6c <rtems_clock_get_ticks_per_second>
4000683c:	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] *                    
40006840:	40 00 4c 53 	call  4001998c <.umul>                         
40006844:	92 10 00 1b 	mov  %i3, %o1                                  
                    rtems_clock_get_ticks_per_second() / 10;          
40006848:	40 00 4c 8b 	call  40019a74 <.udiv>                         
4000684c:	92 10 20 0a 	mov  0xa, %o1                                  
      if (tty->termios.c_cc[VTIME]) {                                 
40006850:	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] *                    
40006854:	d0 27 60 54 	st  %o0, [ %i5 + 0x54 ]                        
                    rtems_clock_get_ticks_per_second() / 10;          
      if (tty->termios.c_cc[VTIME]) {                                 
40006858:	80 a0 60 00 	cmp  %g1, 0                                    
4000685c:	02 80 00 26 	be  400068f4 <rtems_termios_ioctl+0x470>       
40006860:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      
        tty->rawInBufSemaphoreOptions = RTEMS_WAIT;                   
40006864:	c0 27 60 6c 	clr  [ %i5 + 0x6c ]                            
        tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;              
        if (tty->termios.c_cc[VMIN])                                  
40006868:	80 a0 60 00 	cmp  %g1, 0                                    
4000686c:	12 bf ff a6 	bne  40006704 <rtems_termios_ioctl+0x280>      
40006870:	d0 27 60 70 	st  %o0, [ %i5 + 0x70 ]                        
          tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;      
        else                                                          
          tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;       
40006874:	10 bf ff a5 	b  40006708 <rtems_termios_ioctl+0x284>        
40006878:	d0 27 60 74 	st  %o0, [ %i5 + 0x74 ]                        
static void                                                           
flushOutput (struct rtems_termios_tty *tty)                           
{                                                                     
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable (level);                                    
4000687c:	7f ff ef 15 	call  400024d0 <sparc_disable_interrupts>      
40006880:	01 00 00 00 	nop                                            
  tty->rawOutBuf.Tail = 0;                                            
40006884:	c0 27 60 84 	clr  [ %i5 + 0x84 ]                            
  tty->rawOutBuf.Head = 0;                                            
40006888:	c0 27 60 80 	clr  [ %i5 + 0x80 ]                            
  tty->rawOutBufState = rob_idle;                                     
4000688c:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
  rtems_interrupt_enable (level);                                     
40006890:	7f ff ef 14 	call  400024e0 <sparc_enable_interrupts>       
40006894:	01 00 00 00 	nop                                            
40006898:	30 bf ff 27 	b,a   40006534 <rtems_termios_ioctl+0xb0>      
    break;                                                            
#endif                                                                
   case FIONREAD: {                                                   
      int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;            
      if ( rawnc < 0 )                                                
        rawnc += tty->rawInBuf.Size;                                  
4000689c:	c4 07 60 64 	ld  [ %i5 + 0x64 ], %g2                        <== NOT EXECUTED
400068a0:	10 bf ff a7 	b  4000673c <rtems_termios_ioctl+0x2b8>        <== NOT EXECUTED
400068a4:	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;                                       
400068a8:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
400068ac:	82 10 61 00 	or  %g1, 0x100, %g1                            <== NOT EXECUTED
400068b0:	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) {                                 
400068b4:	10 bf ff 81 	b  400066b8 <rtems_termios_ioctl+0x234>        <== NOT EXECUTED
400068b8:	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);                                    
400068bc:	7f ff ef 05 	call  400024d0 <sparc_disable_interrupts>      
400068c0:	01 00 00 00 	nop                                            
  tty->rawOutBuf.Tail = 0;                                            
400068c4:	c0 27 60 84 	clr  [ %i5 + 0x84 ]                            
  tty->rawOutBuf.Head = 0;                                            
400068c8:	c0 27 60 80 	clr  [ %i5 + 0x80 ]                            
  tty->rawOutBufState = rob_idle;                                     
400068cc:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
  rtems_interrupt_enable (level);                                     
400068d0:	7f ff ef 04 	call  400024e0 <sparc_enable_interrupts>       
400068d4:	01 00 00 00 	nop                                            
static void                                                           
flushInput (struct rtems_termios_tty *tty)                            
{                                                                     
  rtems_interrupt_level level;                                        
                                                                      
  rtems_interrupt_disable (level);                                    
400068d8:	7f ff ee fe 	call  400024d0 <sparc_disable_interrupts>      
400068dc:	01 00 00 00 	nop                                            
  tty->rawInBuf.Tail = 0;                                             
400068e0:	c0 27 60 60 	clr  [ %i5 + 0x60 ]                            
  tty->rawInBuf.Head = 0;                                             
400068e4:	c0 27 60 5c 	clr  [ %i5 + 0x5c ]                            
  rtems_interrupt_enable (level);                                     
400068e8:	7f ff ee fe 	call  400024e0 <sparc_enable_interrupts>       
400068ec:	01 00 00 00 	nop                                            
400068f0:	30 bf ff 11 	b,a   40006534 <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]) {                                
400068f4:	80 a0 60 00 	cmp  %g1, 0                                    
400068f8:	32 bf ff 82 	bne,a   40006700 <rtems_termios_ioctl+0x27c>   <== NEVER TAKEN
400068fc:	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;              
40006900:	82 10 20 01 	mov  1, %g1                                    
40006904:	10 bf ff 81 	b  40006708 <rtems_termios_ioctl+0x284>        
40006908:	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); 
4000690c:	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)(                                         
40006910:	d2 07 60 7c 	ld  [ %i5 + 0x7c ], %o1                        <== NOT EXECUTED
40006914:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
40006918:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
4000691c:	92 02 40 02 	add  %o1, %g2, %o1                             <== NOT EXECUTED
40006920:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40006924:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
40006928:	30 bf ff 37 	b,a   40006604 <rtems_termios_ioctl+0x180>     <== NOT EXECUTED
                                                                      

40005e44 <rtems_termios_open>: rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) {
40005e44:	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(                                        
40005e48:	23 10 00 80 	sethi  %hi(0x40020000), %l1                    
40005e4c:	d0 04 61 60 	ld  [ %l1 + 0x160 ], %o0	! 40020160 <rtems_termios_ttyMutex>
40005e50:	92 10 20 00 	clr  %o1                                       
40005e54:	94 10 20 00 	clr  %o2                                       
40005e58:	40 00 09 cd 	call  4000858c <rtems_semaphore_obtain>        
40005e5c:	b8 10 00 18 	mov  %i0, %i4                                  
    rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);            
  if (sc != RTEMS_SUCCESSFUL)                                         
40005e60:	80 a2 20 00 	cmp  %o0, 0                                    
40005e64:	12 80 00 28 	bne  40005f04 <rtems_termios_open+0xc0>        <== NEVER TAKEN
40005e68:	a0 10 00 08 	mov  %o0, %l0                                  
    return sc;                                                        
                                                                      
  for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 
40005e6c:	25 10 00 80 	sethi  %hi(0x40020000), %l2                    
40005e70:	f0 04 a1 68 	ld  [ %l2 + 0x168 ], %i0	! 40020168 <rtems_termios_ttyHead>
40005e74:	80 a6 20 00 	cmp  %i0, 0                                    
40005e78:	02 80 00 25 	be  40005f0c <rtems_termios_open+0xc8>         
40005e7c:	ba 10 00 18 	mov  %i0, %i5                                  
    if ((tty->major == major) && (tty->minor == minor))               
40005e80:	10 80 00 06 	b  40005e98 <rtems_termios_open+0x54>          
40005e84:	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) { 
40005e88:	80 a7 60 00 	cmp  %i5, 0                                    
40005e8c:	02 80 00 21 	be  40005f10 <rtems_termios_open+0xcc>         <== ALWAYS TAKEN
40005e90:	90 10 20 01 	mov  1, %o0                                    
    if ((tty->major == major) && (tty->minor == minor))               
40005e94:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         <== NOT EXECUTED
40005e98:	80 a0 40 1c 	cmp  %g1, %i4                                  
40005e9c:	32 bf ff fb 	bne,a   40005e88 <rtems_termios_open+0x44>     
40005ea0:	fa 07 40 00 	ld  [ %i5 ], %i5                               
40005ea4:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
40005ea8:	80 a0 40 19 	cmp  %g1, %i1                                  
40005eac:	32 bf ff f7 	bne,a   40005e88 <rtems_termios_open+0x44>     <== NEVER TAKEN
40005eb0:	fa 07 40 00 	ld  [ %i5 ], %i5                               <== NOT EXECUTED
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
                                                                      
  }                                                                   
  args->iop->data1 = tty;                                             
40005eb4:	c4 06 80 00 	ld  [ %i2 ], %g2                               
  if (!tty->refcount++) {                                             
40005eb8:	c2 07 60 08 	ld  [ %i5 + 8 ], %g1                           
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
                                                                      
  }                                                                   
  args->iop->data1 = tty;                                             
40005ebc:	fa 20 a0 30 	st  %i5, [ %g2 + 0x30 ]                        
  if (!tty->refcount++) {                                             
40005ec0:	84 00 60 01 	add  %g1, 1, %g2                               
40005ec4:	80 a0 60 00 	cmp  %g1, 0                                    
40005ec8:	12 80 00 0d 	bne  40005efc <rtems_termios_open+0xb8>        
40005ecc:	c4 27 60 08 	st  %g2, [ %i5 + 8 ]                           
    if (tty->device.firstOpen)                                        
40005ed0:	c2 07 60 98 	ld  [ %i5 + 0x98 ], %g1                        
40005ed4:	80 a0 60 00 	cmp  %g1, 0                                    
40005ed8:	02 80 00 05 	be  40005eec <rtems_termios_open+0xa8>         <== ALWAYS TAKEN
40005edc:	90 10 00 1c 	mov  %i4, %o0                                  
      (*tty->device.firstOpen)(major, minor, arg);                    
40005ee0:	92 10 00 19 	mov  %i1, %o1                                  <== NOT EXECUTED
40005ee4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40005ee8:	94 10 00 1a 	mov  %i2, %o2                                  <== NOT EXECUTED
                                                                      
    /*                                                                
     * start I/O tasks, if needed                                     
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
40005eec:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40005ef0:	80 a0 60 02 	cmp  %g1, 2                                    
40005ef4:	22 80 00 9e 	be,a   4000616c <rtems_termios_open+0x328>     
40005ef8:	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);                   
40005efc:	40 00 09 f3 	call  400086c8 <rtems_semaphore_release>       
40005f00:	d0 04 61 60 	ld  [ %l1 + 0x160 ], %o0                       
  return RTEMS_SUCCESSFUL;                                            
}                                                                     
40005f04:	81 c7 e0 08 	ret                                            
40005f08:	91 e8 00 10 	restore  %g0, %l0, %o0                         
    static char c = 'a';                                              
                                                                      
    /*                                                                
     * Create a new device                                            
     */                                                               
    tty = calloc (1, sizeof (struct rtems_termios_tty));              
40005f0c:	90 10 20 01 	mov  1, %o0                                    
40005f10:	7f ff f8 0f 	call  40003f4c <calloc>                        
40005f14:	92 10 20 e8 	mov  0xe8, %o1                                 
    if (tty == NULL) {                                                
40005f18:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40005f1c:	02 80 00 a9 	be  400061c0 <rtems_termios_open+0x37c>        
40005f20:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate raw input buffer                                      
     */                                                               
    tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;                       
40005f24:	c2 00 61 e0 	ld  [ %g1 + 0x1e0 ], %g1	! 4001f5e0 <rtems_termios_raw_input_size>
40005f28:	c2 27 60 64 	st  %g1, [ %i5 + 0x64 ]                        
    tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);               
40005f2c:	d0 07 60 64 	ld  [ %i5 + 0x64 ], %o0                        
40005f30:	7f ff f9 90 	call  40004570 <malloc>                        
40005f34:	01 00 00 00 	nop                                            
40005f38:	d0 27 60 58 	st  %o0, [ %i5 + 0x58 ]                        
    if (tty->rawInBuf.theBuf == NULL) {                               
40005f3c:	80 a2 20 00 	cmp  %o0, 0                                    
40005f40:	02 80 00 9e 	be  400061b8 <rtems_termios_open+0x374>        
40005f44:	a6 10 00 08 	mov  %o0, %l3                                  
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate raw output buffer                                     
     */                                                               
    tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;                     
40005f48:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
40005f4c:	c2 00 61 e4 	ld  [ %g1 + 0x1e4 ], %g1	! 4001f5e4 <rtems_termios_raw_output_size>
40005f50:	c2 27 60 88 	st  %g1, [ %i5 + 0x88 ]                        
    tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);             
40005f54:	d0 07 60 88 	ld  [ %i5 + 0x88 ], %o0                        
40005f58:	7f ff f9 86 	call  40004570 <malloc>                        
40005f5c:	01 00 00 00 	nop                                            
40005f60:	d0 27 60 7c 	st  %o0, [ %i5 + 0x7c ]                        
    if (tty->rawOutBuf.theBuf == NULL) {                              
40005f64:	80 a2 20 00 	cmp  %o0, 0                                    
40005f68:	02 80 00 92 	be  400061b0 <rtems_termios_open+0x36c>        
40005f6c:	a8 10 00 08 	mov  %o0, %l4                                  
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * allocate cooked buffer                                         
     */                                                               
    tty->cbuf  = malloc (CBUFSIZE);                                   
40005f70:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
40005f74:	7f ff f9 7f 	call  40004570 <malloc>                        
40005f78:	d0 00 61 e8 	ld  [ %g1 + 0x1e8 ], %o0	! 4001f5e8 <rtems_termios_cbufsize>
    if (tty->cbuf == NULL) {                                          
40005f7c:	80 a2 20 00 	cmp  %o0, 0                                    
40005f80:	02 80 00 8a 	be  400061a8 <rtems_termios_open+0x364>        
40005f84:	d0 27 60 1c 	st  %o0, [ %i5 + 0x1c ]                        
      return RTEMS_NO_MEMORY;                                         
    }                                                                 
    /*                                                                
     * Initialize wakeup callbacks                                    
     */                                                               
    tty->tty_snd.sw_pfn = NULL;                                       
40005f88:	c0 27 60 d4 	clr  [ %i5 + 0xd4 ]                            
    tty->tty_snd.sw_arg = NULL;                                       
40005f8c:	c0 27 60 d8 	clr  [ %i5 + 0xd8 ]                            
    tty->tty_rcv.sw_pfn = NULL;                                       
40005f90:	c0 27 60 dc 	clr  [ %i5 + 0xdc ]                            
    tty->tty_rcv.sw_arg = NULL;                                       
40005f94:	c0 27 60 e0 	clr  [ %i5 + 0xe0 ]                            
    tty->tty_rcvwakeup  = 0;                                          
40005f98:	c0 27 60 e4 	clr  [ %i5 + 0xe4 ]                            
                                                                      
    /*                                                                
     * link tty                                                       
     */                                                               
    tty->forw = rtems_termios_ttyHead;                                
40005f9c:	f0 27 40 00 	st  %i0, [ %i5 ]                               
    tty->back = NULL;                                                 
    if (rtems_termios_ttyHead != NULL)                                
40005fa0:	80 a6 20 00 	cmp  %i0, 0                                    
40005fa4:	02 80 00 03 	be  40005fb0 <rtems_termios_open+0x16c>        
40005fa8:	c0 27 60 04 	clr  [ %i5 + 4 ]                               
      rtems_termios_ttyHead->back = tty;                              
40005fac:	fa 26 20 04 	st  %i5, [ %i0 + 4 ]                           
    rtems_termios_ttyHead = tty;                                      
    if (rtems_termios_ttyTail == NULL)                                
40005fb0:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
40005fb4:	c4 00 61 64 	ld  [ %g1 + 0x164 ], %g2	! 40020164 <rtems_termios_ttyTail>
40005fb8:	80 a0 a0 00 	cmp  %g2, 0                                    
40005fbc:	02 80 00 ac 	be  4000626c <rtems_termios_open+0x428>        
40005fc0:	fa 24 a1 68 	st  %i5, [ %l2 + 0x168 ]                       
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'i', c),                            
40005fc4:	31 10 00 7d 	sethi  %hi(0x4001f400), %i0                    
40005fc8:	d0 4e 21 ec 	ldsb  [ %i0 + 0x1ec ], %o0	! 4001f5ec <c.6875> 
    tty->major = major;                                               
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
40005fcc:	03 15 14 9a 	sethi  %hi(0x54526800), %g1                    
40005fd0:	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;                                               
40005fd4:	f2 27 60 10 	st  %i1, [ %i5 + 0x10 ]                        
    tty->major = major;                                               
40005fd8:	f8 27 60 0c 	st  %i4, [ %i5 + 0xc ]                         
                                                                      
    /*                                                                
     * Set up mutex semaphores                                        
     */                                                               
    sc = rtems_semaphore_create (                                     
40005fdc:	92 10 20 01 	mov  1, %o1                                    
40005fe0:	94 10 20 54 	mov  0x54, %o2                                 
40005fe4:	90 12 00 01 	or  %o0, %g1, %o0                              
40005fe8:	96 10 20 00 	clr  %o3                                       
40005fec:	40 00 08 c0 	call  400082ec <rtems_semaphore_create>        
40005ff0:	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)                                       
40005ff4:	80 a2 20 00 	cmp  %o0, 0                                    
40005ff8:	12 80 00 84 	bne  40006208 <rtems_termios_open+0x3c4>       
40005ffc:	03 15 14 9b 	sethi  %hi(0x54526c00), %g1                    
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'o', c),                            
40006000:	d0 4e 21 ec 	ldsb  [ %i0 + 0x1ec ], %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 (                                     
40006004:	82 10 63 00 	or  %g1, 0x300, %g1                            
40006008:	92 10 20 01 	mov  1, %o1                                    
4000600c:	94 10 20 54 	mov  0x54, %o2                                 
40006010:	90 12 00 01 	or  %o0, %g1, %o0                              
40006014:	96 10 20 00 	clr  %o3                                       
40006018:	40 00 08 b5 	call  400082ec <rtems_semaphore_create>        
4000601c:	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)                                       
40006020:	80 a2 20 00 	cmp  %o0, 0                                    
40006024:	12 80 00 79 	bne  40006208 <rtems_termios_open+0x3c4>       
40006028:	03 15 14 9e 	sethi  %hi(0x54527800), %g1                    
      rtems_fatal_error_occurred (sc);                                
    sc = rtems_semaphore_create (                                     
      rtems_build_name ('T', 'R', 'x', c),                            
4000602c:	d0 4e 21 ec 	ldsb  [ %i0 + 0x1ec ], %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 (                                     
40006030:	92 10 20 00 	clr  %o1                                       
40006034:	90 12 00 01 	or  %o0, %g1, %o0                              
40006038:	94 10 20 20 	mov  0x20, %o2                                 
4000603c:	96 10 20 00 	clr  %o3                                       
40006040:	40 00 08 ab 	call  400082ec <rtems_semaphore_create>        
40006044:	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)                                       
40006048:	80 a2 20 00 	cmp  %o0, 0                                    
4000604c:	12 80 00 6f 	bne  40006208 <rtems_termios_open+0x3c4>       
40006050:	92 10 00 1b 	mov  %i3, %o1                                  
      rtems_fatal_error_occurred (sc);                                
    tty->rawOutBufState = rob_idle;                                   
40006054:	c0 27 60 94 	clr  [ %i5 + 0x94 ]                            
                                                                      
    /*                                                                
     * Set callbacks                                                  
     */                                                               
    tty->device = *callbacks;                                         
40006058:	90 07 60 98 	add  %i5, 0x98, %o0                            
4000605c:	40 00 2c 8a 	call  40011284 <memcpy>                        
40006060:	94 10 20 20 	mov  0x20, %o2                                 
                                                                      
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
40006064:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40006068:	80 a0 60 02 	cmp  %g1, 2                                    
4000606c:	02 80 00 69 	be  40006210 <rtems_termios_open+0x3cc>        
40006070:	d0 4e 21 ec 	ldsb  [ %i0 + 0x1ec ], %o0                     
           &tty->rxTaskId);                                           
      if (sc != RTEMS_SUCCESSFUL)                                     
        rtems_fatal_error_occurred (sc);                              
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
40006074:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
40006078:	80 a0 60 00 	cmp  %g1, 0                                    
4000607c:	02 80 00 58 	be  400061dc <rtems_termios_open+0x398>        
40006080:	d0 4e 21 ec 	ldsb  [ %i0 + 0x1ec ], %o0                     
40006084:	c2 07 60 b4 	ld  [ %i5 + 0xb4 ], %g1                        
40006088:	80 a0 60 02 	cmp  %g1, 2                                    
4000608c:	02 80 00 55 	be  400061e0 <rtems_termios_open+0x39c>        
40006090:	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;                                               
40006094:	c0 27 60 b8 	clr  [ %i5 + 0xb8 ]                            
    /*                                                                
     * set low/highwater mark for XON/XOFF support                    
     */                                                               
    tty->lowwater  = tty->rawInBuf.Size * 1/2;                        
40006098:	c4 07 60 64 	ld  [ %i5 + 0x64 ], %g2                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
4000609c:	c2 07 60 64 	ld  [ %i5 + 0x64 ], %g1                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
400060a0:	c6 4e 21 ec 	ldsb  [ %i0 + 0x1ec ], %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;                        
400060a4:	89 28 60 01 	sll  %g1, 1, %g4                               
400060a8:	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;                     
400060ac:	09 00 00 06 	sethi  %hi(0x1800), %g4                        
400060b0:	88 11 20 05 	or  %g4, 5, %g4	! 1805 <PROM_START+0x1805>     
400060b4:	c8 27 60 34 	st  %g4, [ %i5 + 0x34 ]                        
    tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;              
400060b8:	88 10 28 bd 	mov  0x8bd, %g4                                
400060bc:	c8 27 60 38 	st  %g4, [ %i5 + 0x38 ]                        
    tty->termios.c_lflag =                                            
400060c0:	09 00 00 20 	sethi  %hi(0x8000), %g4                        
400060c4:	88 11 22 3b 	or  %g4, 0x23b, %g4	! 823b <PROM_START+0x823b> 
400060c8:	c8 27 60 3c 	st  %g4, [ %i5 + 0x3c ]                        
       ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;       
                                                                      
    tty->termios.c_cc[VINTR] = '\003';                                
400060cc:	88 10 20 03 	mov  3, %g4                                    
400060d0:	c8 2f 60 41 	stb  %g4, [ %i5 + 0x41 ]                       
    tty->termios.c_cc[VQUIT] = '\034';                                
400060d4:	88 10 20 1c 	mov  0x1c, %g4                                 
400060d8:	c8 2f 60 42 	stb  %g4, [ %i5 + 0x42 ]                       
    tty->termios.c_cc[VERASE] = '\177';                               
400060dc:	88 10 20 7f 	mov  0x7f, %g4                                 
400060e0:	c8 2f 60 43 	stb  %g4, [ %i5 + 0x43 ]                       
    tty->termios.c_cc[VKILL] = '\025';                                
400060e4:	88 10 20 15 	mov  0x15, %g4                                 
400060e8:	c8 2f 60 44 	stb  %g4, [ %i5 + 0x44 ]                       
    tty->termios.c_cc[VEOF] = '\004';                                 
400060ec:	88 10 20 04 	mov  4, %g4                                    
400060f0:	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';                               
400060f4:	88 10 20 11 	mov  0x11, %g4                                 
400060f8:	c8 2f 60 49 	stb  %g4, [ %i5 + 0x49 ]                       
    tty->termios.c_cc[VSTOP] = '\023';                                
400060fc:	88 10 20 13 	mov  0x13, %g4                                 
40006100:	c8 2f 60 4a 	stb  %g4, [ %i5 + 0x4a ]                       
    tty->termios.c_cc[VSUSP] = '\032';                                
40006104:	88 10 20 1a 	mov  0x1a, %g4                                 
40006108:	c8 2f 60 4b 	stb  %g4, [ %i5 + 0x4b ]                       
    tty->termios.c_cc[VREPRINT] = '\022';                             
4000610c:	88 10 20 12 	mov  0x12, %g4                                 
40006110:	c8 2f 60 4d 	stb  %g4, [ %i5 + 0x4d ]                       
    tty->termios.c_cc[VDISCARD] = '\017';                             
40006114:	88 10 20 0f 	mov  0xf, %g4                                  
40006118:	c8 2f 60 4e 	stb  %g4, [ %i5 + 0x4e ]                       
    tty->termios.c_cc[VWERASE] = '\027';                              
4000611c:	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;                        
40006120:	85 30 a0 01 	srl  %g2, 1, %g2                               
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
40006124:	83 30 60 02 	srl  %g1, 2, %g1                               
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
40006128:	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';                              
4000612c:	c8 2f 60 4f 	stb  %g4, [ %i5 + 0x4f ]                       
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
40006130:	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';                               
40006134:	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;                        
40006138:	c4 27 60 bc 	st  %g2, [ %i5 + 0xbc ]                        
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
4000613c:	c2 27 60 c0 	st  %g1, [ %i5 + 0xc0 ]                        
    }                                                                 
                                                                      
    /*                                                                
     * Set default parameters                                         
     */                                                               
    tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;           
40006140:	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';                                 
40006144:	c0 2f 60 4c 	clrb  [ %i5 + 0x4c ]                           
    tty->termios.c_cc[VEOL2] = '\000';                                
40006148:	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';                               
4000614c:	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')                                                   
40006150:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
40006154:	80 a0 e0 7a 	cmp  %g3, 0x7a                                 
40006158:	02 80 00 1e 	be  400061d0 <rtems_termios_open+0x38c>        
4000615c:	c4 0e 21 ec 	ldub  [ %i0 + 0x1ec ], %g2                     
40006160:	84 00 a0 01 	inc  %g2                                       
40006164:	10 bf ff 54 	b  40005eb4 <rtems_termios_open+0x70>          
40006168:	c4 28 61 ec 	stb  %g2, [ %g1 + 0x1ec ]                      
                                                                      
    /*                                                                
     * start I/O tasks, if needed                                     
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
      sc = rtems_task_start(                                          
4000616c:	94 10 00 1d 	mov  %i5, %o2                                  
40006170:	13 10 00 1e 	sethi  %hi(0x40007800), %o1                    
40006174:	40 00 0a 39 	call  40008a58 <rtems_task_start>              
40006178:	92 12 60 d8 	or  %o1, 0xd8, %o1	! 400078d8 <rtems_termios_rxdaemon>
        tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
4000617c:	80 a2 20 00 	cmp  %o0, 0                                    
40006180:	12 80 00 22 	bne  40006208 <rtems_termios_open+0x3c4>       <== NEVER TAKEN
40006184:	94 10 00 1d 	mov  %i5, %o2                                  
        rtems_fatal_error_occurred (sc);                              
                                                                      
      sc = rtems_task_start(                                          
40006188:	d0 07 60 c8 	ld  [ %i5 + 0xc8 ], %o0                        
4000618c:	13 10 00 17 	sethi  %hi(0x40005c00), %o1                    
40006190:	40 00 0a 32 	call  40008a58 <rtems_task_start>              
40006194:	92 12 61 58 	or  %o1, 0x158, %o1	! 40005d58 <rtems_termios_txdaemon>
        tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
      if (sc != RTEMS_SUCCESSFUL)                                     
40006198:	80 a2 20 00 	cmp  %o0, 0                                    
4000619c:	02 bf ff 58 	be  40005efc <rtems_termios_open+0xb8>         <== ALWAYS TAKEN
400061a0:	01 00 00 00 	nop                                            
400061a4:	30 80 00 19 	b,a   40006208 <rtems_termios_open+0x3c4>      <== NOT EXECUTED
    /*                                                                
     * allocate cooked buffer                                         
     */                                                               
    tty->cbuf  = malloc (CBUFSIZE);                                   
    if (tty->cbuf == NULL) {                                          
            free((void *)(tty->rawOutBuf.theBuf));                    
400061a8:	7f ff f8 18 	call  40004208 <free>                          
400061ac:	90 10 00 14 	mov  %l4, %o0                                  
            free((void *)(tty->rawInBuf.theBuf));                     
400061b0:	7f ff f8 16 	call  40004208 <free>                          
400061b4:	90 10 00 13 	mov  %l3, %o0                                  
            free(tty);                                                
400061b8:	7f ff f8 14 	call  40004208 <free>                          
400061bc:	90 10 00 1d 	mov  %i5, %o0                                  
      rtems_semaphore_release (rtems_termios_ttyMutex);               
400061c0:	d0 04 61 60 	ld  [ %l1 + 0x160 ], %o0                       
400061c4:	40 00 09 41 	call  400086c8 <rtems_semaphore_release>       
400061c8:	a0 10 20 1a 	mov  0x1a, %l0                                 
      return RTEMS_NO_MEMORY;                                         
400061cc:	30 bf ff 4e 	b,a   40005f04 <rtems_termios_open+0xc0>       
    tty->highwater = tty->rawInBuf.Size * 3/4;                        
    /*                                                                
     * Bump name characer                                             
     */                                                               
    if (c++ == 'z')                                                   
      c = 'a';                                                        
400061d0:	84 10 20 61 	mov  0x61, %g2                                 
400061d4:	10 bf ff 38 	b  40005eb4 <rtems_termios_open+0x70>          
400061d8:	c4 28 61 ec 	stb  %g2, [ %g1 + 0x1ec ]                      
        rtems_fatal_error_occurred (sc);                              
                                                                      
    }                                                                 
    if ((tty->device.pollRead == NULL) ||                             
        (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){   
      sc = rtems_semaphore_create (                                   
400061dc:	03 15 14 9c 	sethi  %hi(0x54527000), %g1                    
400061e0:	82 10 62 00 	or  %g1, 0x200, %g1	! 54527200 <RAM_END+0x14127200>
400061e4:	92 10 20 00 	clr  %o1                                       
400061e8:	94 10 20 24 	mov  0x24, %o2                                 
400061ec:	90 12 00 01 	or  %o0, %g1, %o0                              
400061f0:	96 10 20 00 	clr  %o3                                       
400061f4:	40 00 08 3e 	call  400082ec <rtems_semaphore_create>        
400061f8:	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)                                     
400061fc:	80 a2 20 00 	cmp  %o0, 0                                    
40006200:	02 bf ff a5 	be  40006094 <rtems_termios_open+0x250>        <== ALWAYS TAKEN
40006204:	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);                              
40006208:	40 00 0a c6 	call  40008d20 <rtems_fatal_error_occurred>    
4000620c:	01 00 00 00 	nop                                            
                                                                      
    /*                                                                
     * Create I/O tasks                                               
     */                                                               
    if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {    
      sc = rtems_task_create (                                        
40006210:	03 15 1e 15 	sethi  %hi(0x54785400), %g1                    
40006214:	92 10 20 0a 	mov  0xa, %o1                                  
40006218:	90 12 00 01 	or  %o0, %g1, %o0                              
4000621c:	94 10 24 00 	mov  0x400, %o2                                
40006220:	96 10 25 00 	mov  0x500, %o3                                
40006224:	98 10 20 00 	clr  %o4                                       
40006228:	40 00 09 68 	call  400087c8 <rtems_task_create>             
4000622c:	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)                                     
40006230:	80 a2 20 00 	cmp  %o0, 0                                    
40006234:	12 bf ff f5 	bne  40006208 <rtems_termios_open+0x3c4>       <== NEVER TAKEN
40006238:	03 14 9e 15 	sethi  %hi(0x52785400), %g1                    
        rtems_fatal_error_occurred (sc);                              
      sc = rtems_task_create (                                        
                                   rtems_build_name ('R', 'x', 'T', c),
4000623c:	d0 4e 21 ec 	ldsb  [ %i0 + 0x1ec ], %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 (                                        
40006240:	92 10 20 09 	mov  9, %o1                                    
40006244:	90 12 00 01 	or  %o0, %g1, %o0                              
40006248:	94 10 24 00 	mov  0x400, %o2                                
4000624c:	96 10 25 00 	mov  0x500, %o3                                
40006250:	98 10 20 00 	clr  %o4                                       
40006254:	40 00 09 5d 	call  400087c8 <rtems_task_create>             
40006258:	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)                                     
4000625c:	80 a2 20 00 	cmp  %o0, 0                                    
40006260:	22 bf ff 86 	be,a   40006078 <rtems_termios_open+0x234>     <== ALWAYS TAKEN
40006264:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
40006268:	30 bf ff e8 	b,a   40006208 <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;                                    
4000626c:	10 bf ff 56 	b  40005fc4 <rtems_termios_open+0x180>         
40006270:	fa 20 61 64 	st  %i5, [ %g1 + 0x164 ]                       
                                                                      

4000692c <rtems_termios_puts>: * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, size_t len, struct rtems_termios_tty *tty) {
4000692c:	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) {           
40006930:	c2 06 a0 b4 	ld  [ %i2 + 0xb4 ], %g1                        
40006934:	80 a0 60 00 	cmp  %g1, 0                                    
40006938:	22 80 00 44 	be,a   40006a48 <rtems_termios_puts+0x11c>     
4000693c:	c2 06 a0 a4 	ld  [ %i2 + 0xa4 ], %g1                        
    (*tty->device.write)(tty->minor, buf, len);                       
    return;                                                           
  }                                                                   
  newHead = tty->rawOutBuf.Head;                                      
40006940:	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;                                 
40006944:	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) {                                                       
40006948:	80 a6 60 00 	cmp  %i1, 0                                    
4000694c:	02 80 00 34 	be  40006a1c <rtems_termios_puts+0xf0>         <== NEVER TAKEN
40006950:	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;                    
40006954:	d2 06 a0 88 	ld  [ %i2 + 0x88 ], %o1                        
40006958:	40 00 4c f3 	call  40019d24 <.urem>                         
4000695c:	90 04 20 01 	add  %l0, 1, %o0                               
    rtems_interrupt_disable (level);                                  
40006960:	7f ff ee dc 	call  400024d0 <sparc_disable_interrupts>      
40006964:	a0 10 00 08 	mov  %o0, %l0                                  
40006968:	ba 10 00 08 	mov  %o0, %i5                                  
    while (newHead == tty->rawOutBuf.Tail) {                          
4000696c:	f8 06 a0 84 	ld  [ %i2 + 0x84 ], %i4                        
40006970:	80 a7 00 10 	cmp  %i4, %l0                                  
40006974:	32 80 00 14 	bne,a   400069c4 <rtems_termios_puts+0x98>     
40006978:	c6 0e 00 00 	ldub  [ %i0 ], %g3                             
      tty->rawOutBufState = rob_wait;                                 
4000697c:	f6 26 a0 94 	st  %i3, [ %i2 + 0x94 ]                        
      rtems_interrupt_enable (level);                                 
40006980:	7f ff ee d8 	call  400024e0 <sparc_enable_interrupts>       
40006984:	90 10 00 1d 	mov  %i5, %o0                                  
      sc = rtems_semaphore_obtain(                                    
40006988:	d0 06 a0 8c 	ld  [ %i2 + 0x8c ], %o0                        
4000698c:	92 10 20 00 	clr  %o1                                       
40006990:	40 00 06 ff 	call  4000858c <rtems_semaphore_obtain>        
40006994:	94 10 20 00 	clr  %o2                                       
        tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);      
      if (sc != RTEMS_SUCCESSFUL)                                     
40006998:	80 a2 20 00 	cmp  %o0, 0                                    
4000699c:	12 80 00 31 	bne  40006a60 <rtems_termios_puts+0x134>       <== NEVER TAKEN
400069a0:	01 00 00 00 	nop                                            
        rtems_fatal_error_occurred (sc);                              
      rtems_interrupt_disable (level);                                
400069a4:	7f ff ee cb 	call  400024d0 <sparc_disable_interrupts>      
400069a8:	01 00 00 00 	nop                                            
400069ac:	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) {                          
400069b0:	c2 06 a0 84 	ld  [ %i2 + 0x84 ], %g1                        
400069b4:	80 a0 40 1c 	cmp  %g1, %i4                                  
400069b8:	22 bf ff f2 	be,a   40006980 <rtems_termios_puts+0x54>      <== NEVER TAKEN
400069bc:	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++;              
400069c0:	c6 0e 00 00 	ldub  [ %i0 ], %g3                             
400069c4:	c2 06 a0 80 	ld  [ %i2 + 0x80 ], %g1                        
400069c8:	c4 06 a0 7c 	ld  [ %i2 + 0x7c ], %g2                        
400069cc:	b0 06 20 01 	inc  %i0                                       
400069d0:	c6 28 80 01 	stb  %g3, [ %g2 + %g1 ]                        
    tty->rawOutBuf.Head = newHead;                                    
    if (tty->rawOutBufState == rob_idle) {                            
400069d4:	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;                                    
400069d8:	e0 26 a0 80 	st  %l0, [ %i2 + 0x80 ]                        
    if (tty->rawOutBufState == rob_idle) {                            
400069dc:	80 a0 60 00 	cmp  %g1, 0                                    
400069e0:	12 80 00 0a 	bne  40006a08 <rtems_termios_puts+0xdc>        
400069e4:	01 00 00 00 	nop                                            
      /* check, whether XOFF has been received */                     
      if (!(tty->flow_ctrl & FL_ORCVXOF)) {                           
400069e8:	c2 06 a0 b8 	ld  [ %i2 + 0xb8 ], %g1                        
400069ec:	80 88 60 10 	btst  0x10, %g1                                
400069f0:	02 80 00 0d 	be  40006a24 <rtems_termios_puts+0xf8>         <== ALWAYS TAKEN
400069f4:	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;                                   
400069f8:	c2 06 a0 b8 	ld  [ %i2 + 0xb8 ], %g1                        <== NOT EXECUTED
400069fc:	82 10 60 20 	or  %g1, 0x20, %g1                             <== NOT EXECUTED
40006a00:	c2 26 a0 b8 	st  %g1, [ %i2 + 0xb8 ]                        <== NOT EXECUTED
      }                                                               
      tty->rawOutBufState = rob_busy;                                 
40006a04:	e2 26 a0 94 	st  %l1, [ %i2 + 0x94 ]                        <== NOT EXECUTED
    }                                                                 
    rtems_interrupt_enable (level);                                   
40006a08:	7f ff ee b6 	call  400024e0 <sparc_enable_interrupts>       
40006a0c:	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) {                                                       
40006a10:	b2 86 7f ff 	addcc  %i1, -1, %i1                            
40006a14:	12 bf ff d0 	bne  40006954 <rtems_termios_puts+0x28>        
40006a18:	01 00 00 00 	nop                                            
40006a1c:	81 c7 e0 08 	ret                                            
40006a20:	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); 
40006a24:	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)(                                         
40006a28:	d2 06 a0 7c 	ld  [ %i2 + 0x7c ], %o1                        
40006a2c:	c2 06 a0 a4 	ld  [ %i2 + 0xa4 ], %g1                        
40006a30:	d0 06 a0 10 	ld  [ %i2 + 0x10 ], %o0                        
40006a34:	92 02 40 02 	add  %o1, %g2, %o1                             
40006a38:	9f c0 40 00 	call  %g1                                      
40006a3c:	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;                                 
40006a40:	10 bf ff f2 	b  40006a08 <rtems_termios_puts+0xdc>          
40006a44:	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);                       
40006a48:	d0 06 a0 10 	ld  [ %i2 + 0x10 ], %o0                        
40006a4c:	92 10 00 18 	mov  %i0, %o1                                  
40006a50:	9f c0 40 00 	call  %g1                                      
40006a54:	94 10 00 19 	mov  %i1, %o2                                  
    return;                                                           
40006a58:	81 c7 e0 08 	ret                                            
40006a5c:	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);                              
40006a60:	40 00 08 b0 	call  40008d20 <rtems_fatal_error_occurred>    <== NOT EXECUTED
                                                                      

400071bc <rtems_termios_read>: return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) {
400071bc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
400071c0:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  uint32_t   count = args->count;                                     
400071c4:	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;                   
400071c8:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  uint32_t   count = args->count;                                     
  char      *buffer = args->buffer;                                   
400071cc:	e4 06 20 10 	ld  [ %i0 + 0x10 ], %l2                        
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400071d0:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
400071d4:	92 10 20 00 	clr  %o1                                       
400071d8:	40 00 04 ed 	call  4000858c <rtems_semaphore_obtain>        
400071dc:	94 10 20 00 	clr  %o2                                       
  if (sc != RTEMS_SUCCESSFUL)                                         
400071e0:	a0 92 20 00 	orcc  %o0, 0, %l0                              
400071e4:	12 80 00 10 	bne  40007224 <rtems_termios_read+0x68>        <== NEVER TAKEN
400071e8:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
    return sc;                                                        
                                                                      
  if (rtems_termios_linesw[tty->t_line].l_read != NULL) {             
400071ec:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
400071f0:	85 28 a0 05 	sll  %g2, 5, %g2                               
400071f4:	82 10 61 34 	or  %g1, 0x134, %g1                            
400071f8:	82 00 40 02 	add  %g1, %g2, %g1                             
400071fc:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
40007200:	80 a0 60 00 	cmp  %g1, 0                                    
40007204:	02 80 00 0a 	be  4000722c <rtems_termios_read+0x70>         
40007208:	90 10 00 1d 	mov  %i5, %o0                                  
    sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);          
4000720c:	9f c0 40 00 	call  %g1                                      
40007210:	92 10 00 18 	mov  %i0, %o1                                  
40007214:	a0 10 00 08 	mov  %o0, %l0                                  
    tty->tty_rcvwakeup = 0;                                           
    rtems_semaphore_release (tty->isem);                              
40007218:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
4000721c:	40 00 05 2b 	call  400086c8 <rtems_semaphore_release>       
40007220:	c0 27 60 e4 	clr  [ %i5 + 0xe4 ]                            
  }                                                                   
  args->bytes_moved = args->count - count;                            
  tty->tty_rcvwakeup = 0;                                             
  rtems_semaphore_release (tty->isem);                                
  return sc;                                                          
}                                                                     
40007224:	81 c7 e0 08 	ret                                            
40007228:	91 e8 00 10 	restore  %g0, %l0, %o0                         
    tty->tty_rcvwakeup = 0;                                           
    rtems_semaphore_release (tty->isem);                              
    return sc;                                                        
  }                                                                   
                                                                      
  if (tty->cindex == tty->ccount) {                                   
4000722c:	c4 07 60 24 	ld  [ %i5 + 0x24 ], %g2                        
40007230:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
40007234:	80 a0 80 01 	cmp  %g2, %g1                                  
40007238:	22 80 00 21 	be,a   400072bc <rtems_termios_read+0x100>     <== ALWAYS TAKEN
4000723c:	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)) {                      
40007240:	80 a6 e0 00 	cmp  %i3, 0                                    
40007244:	22 80 00 15 	be,a   40007298 <rtems_termios_read+0xdc>      <== NEVER TAKEN
40007248:	b6 10 20 00 	clr  %i3                                       <== NOT EXECUTED
4000724c:	c2 07 60 24 	ld  [ %i5 + 0x24 ], %g1                        
40007250:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40007254:	80 a0 40 02 	cmp  %g1, %g2                                  
40007258:	36 80 00 11 	bge,a   4000729c <rtems_termios_read+0xe0>     
4000725c:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
40007260:	10 80 00 06 	b  40007278 <rtems_termios_read+0xbc>          
40007264:	a4 24 80 01 	sub  %l2, %g1, %l2                             
40007268:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
4000726c:	80 a0 80 01 	cmp  %g2, %g1                                  
40007270:	24 80 00 0b 	ble,a   4000729c <rtems_termios_read+0xe0>     
40007274:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
    *buffer++ = tty->cbuf[tty->cindex++];                             
40007278:	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)) {                      
4000727c:	b6 86 ff ff 	addcc  %i3, -1, %i3                            
    *buffer++ = tty->cbuf[tty->cindex++];                             
40007280:	c4 08 80 01 	ldub  [ %g2 + %g1 ], %g2                       
40007284:	c4 2c 80 01 	stb  %g2, [ %l2 + %g1 ]                        
40007288:	82 00 60 01 	inc  %g1                                       
      sc = fillBufferQueue (tty);                                     
                                                                      
    if (sc != RTEMS_SUCCESSFUL)                                       
      tty->cindex = tty->ccount = 0;                                  
  }                                                                   
  while (count && (tty->cindex < tty->ccount)) {                      
4000728c:	12 bf ff f7 	bne  40007268 <rtems_termios_read+0xac>        
40007290:	c2 27 60 24 	st  %g1, [ %i5 + 0x24 ]                        
40007294:	b6 10 20 00 	clr  %i3                                       
    *buffer++ = tty->cbuf[tty->cindex++];                             
    count--;                                                          
  }                                                                   
  args->bytes_moved = args->count - count;                            
40007298:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  tty->tty_rcvwakeup = 0;                                             
  rtems_semaphore_release (tty->isem);                                
4000729c:	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;                            
400072a0:	b6 20 40 1b 	sub  %g1, %i3, %i3                             
400072a4:	f6 26 20 1c 	st  %i3, [ %i0 + 0x1c ]                        
  tty->tty_rcvwakeup = 0;                                             
400072a8:	c0 27 60 e4 	clr  [ %i5 + 0xe4 ]                            
  rtems_semaphore_release (tty->isem);                                
400072ac:	40 00 05 07 	call  400086c8 <rtems_semaphore_release>       
400072b0:	b0 10 00 10 	mov  %l0, %i0                                  
  return sc;                                                          
}                                                                     
400072b4:	81 c7 e0 08 	ret                                            
400072b8:	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 &&                               
400072bc:	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;                                    
400072c0:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
400072c4:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
    tty->read_start_column = tty->column;                             
    if (tty->device.pollRead != NULL &&                               
400072c8:	80 a0 60 00 	cmp  %g1, 0                                    
400072cc:	02 80 00 06 	be  400072e4 <rtems_termios_read+0x128>        
400072d0:	c4 27 60 2c 	st  %g2, [ %i5 + 0x2c ]                        
400072d4:	c4 07 60 b4 	ld  [ %i5 + 0xb4 ], %g2                        
400072d8:	80 a0 a0 00 	cmp  %g2, 0                                    
400072dc:	22 80 00 6d 	be,a   40007490 <rtems_termios_read+0x2d4>     
400072e0:	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;        
400072e4:	f8 07 60 74 	ld  [ %i5 + 0x74 ], %i4                        
  rtems_status_code sc;                                               
  int               wait = 1;                                         
400072e8:	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))) {                
400072ec:	23 10 00 7d 	sethi  %hi(0x4001f400), %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);     
400072f0:	a6 07 60 49 	add  %i5, 0x49, %l3                            
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
400072f4:	c4 07 60 5c 	ld  [ %i5 + 0x5c ], %g2                        
400072f8:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
400072fc:	80 a0 80 01 	cmp  %g2, %g1                                  
40007300:	02 80 00 42 	be  40007408 <rtems_termios_read+0x24c>        
40007304:	c4 04 61 e8 	ld  [ %l1 + 0x1e8 ], %g2                       
40007308:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
                       (tty->ccount < (CBUFSIZE-1))) {                
4000730c:	84 00 bf ff 	add  %g2, -1, %g2                              
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
40007310:	80 a0 80 01 	cmp  %g2, %g1                                  
40007314:	08 80 00 3d 	bleu  40007408 <rtems_termios_read+0x24c>      <== NEVER TAKEN
40007318:	b4 14 61 e8 	or  %l1, 0x1e8, %i2                            
                       (tty->ccount < (CBUFSIZE-1))) {                
      unsigned char c;                                                
      unsigned int newHead;                                           
                                                                      
      newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;        
4000731c:	d0 07 60 5c 	ld  [ %i5 + 0x5c ], %o0                        
40007320:	d2 07 60 64 	ld  [ %i5 + 0x64 ], %o1                        
40007324:	40 00 4a 80 	call  40019d24 <.urem>                         
40007328:	90 02 20 01 	inc  %o0                                       
      c = tty->rawInBuf.theBuf[newHead];                              
4000732c:	c2 07 60 58 	ld  [ %i5 + 0x58 ], %g1                        
40007330:	f8 08 40 08 	ldub  [ %g1 + %o0 ], %i4                       
      tty->rawInBuf.Head = newHead;                                   
40007334:	d0 27 60 5c 	st  %o0, [ %i5 + 0x5c ]                        
      if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)             
40007338:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
4000733c:	c4 07 60 64 	ld  [ %i5 + 0x64 ], %g2                        
          % tty->rawInBuf.Size)                                       
40007340:	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)             
40007344:	82 00 80 01 	add  %g2, %g1, %g1                             
          % tty->rawInBuf.Size)                                       
40007348:	40 00 4a 77 	call  40019d24 <.urem>                         
4000734c:	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)             
40007350:	c2 07 60 bc 	ld  [ %i5 + 0xbc ], %g1                        
40007354:	80 a2 00 01 	cmp  %o0, %g1                                  
40007358:	3a 80 00 18 	bcc,a   400073b8 <rtems_termios_read+0x1fc>    <== NEVER TAKEN
4000735c:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
          % tty->rawInBuf.Size)                                       
         < tty->lowwater) {                                           
        tty->flow_ctrl &= ~FL_IREQXOF;                                
40007360:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40007364:	82 08 7f fe 	and  %g1, -2, %g1                              
40007368:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        
        /* if tx stopped and XON should be sent... */                 
        if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))               
4000736c:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40007370:	82 08 62 02 	and  %g1, 0x202, %g1                           
40007374:	80 a0 62 02 	cmp  %g1, 0x202                                
40007378:	22 80 00 38 	be,a   40007458 <rtems_termios_read+0x29c>     <== NEVER TAKEN
4000737c:	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) {                       
40007380:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40007384:	80 88 61 00 	btst  0x100, %g1                               
40007388:	22 80 00 0c 	be,a   400073b8 <rtems_termios_read+0x1fc>     <== ALWAYS TAKEN
4000738c:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        
          tty->flow_ctrl &= ~FL_IRTSOFF;                              
40007390:	c4 07 60 b8 	ld  [ %i5 + 0xb8 ], %g2                        <== NOT EXECUTED
          /* activate RTS line */                                     
          if (tty->device.startRemoteTx != NULL) {                    
40007394:	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;                              
40007398:	84 08 bf fb 	and  %g2, -5, %g2                              <== NOT EXECUTED
4000739c:	c4 27 60 b8 	st  %g2, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
          /* activate RTS line */                                     
          if (tty->device.startRemoteTx != NULL) {                    
400073a0:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
400073a4:	22 80 00 05 	be,a   400073b8 <rtems_termios_read+0x1fc>     <== NOT EXECUTED
400073a8:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
            tty->device.startRemoteTx(tty->minor);                    
400073ac:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
400073b0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
400073b4:	c2 07 60 3c 	ld  [ %i5 + 0x3c ], %g1                        <== NOT EXECUTED
        if (siproc (c, tty))                                          
400073b8:	90 0f 20 ff 	and  %i4, 0xff, %o0                            
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
400073bc:	80 88 60 02 	btst  2, %g1                                   
400073c0:	02 80 00 1d 	be  40007434 <rtems_termios_read+0x278>        <== NEVER TAKEN
400073c4:	92 10 00 1d 	mov  %i5, %o1                                  
        if (siproc (c, tty))                                          
400073c8:	7f ff ff 36 	call  400070a0 <siproc>                        
400073cc:	01 00 00 00 	nop                                            
400073d0:	80 a2 20 00 	cmp  %o0, 0                                    
400073d4:	32 80 00 02 	bne,a   400073dc <rtems_termios_read+0x220>    
400073d8:	b2 10 20 00 	clr  %i1                                       
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
400073dc:	c4 07 60 5c 	ld  [ %i5 + 0x5c ], %g2                        
400073e0:	c2 07 60 60 	ld  [ %i5 + 0x60 ], %g1                        
400073e4:	80 a0 80 01 	cmp  %g2, %g1                                  
400073e8:	02 80 00 08 	be  40007408 <rtems_termios_read+0x24c>        
400073ec:	f8 07 60 70 	ld  [ %i5 + 0x70 ], %i4                        
                       (tty->ccount < (CBUFSIZE-1))) {                
400073f0:	c2 06 80 00 	ld  [ %i2 ], %g1                               
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
400073f4:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
                       (tty->ccount < (CBUFSIZE-1))) {                
400073f8:	82 00 7f ff 	add  %g1, -1, %g1                              
                                                                      
  while ( wait ) {                                                    
    /*                                                                
     * Process characters read from raw queue                         
     */                                                               
    while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&              
400073fc:	80 a0 80 01 	cmp  %g2, %g1                                  
40007400:	0a bf ff c7 	bcs  4000731c <rtems_termios_read+0x160>       <== ALWAYS TAKEN
40007404:	01 00 00 00 	nop                                            
    }                                                                 
                                                                      
    /*                                                                
     * Wait for characters                                            
     */                                                               
    if ( wait ) {                                                     
40007408:	80 a6 60 00 	cmp  %i1, 0                                    
4000740c:	02 bf ff 8e 	be  40007244 <rtems_termios_read+0x88>         
40007410:	80 a6 e0 00 	cmp  %i3, 0                                    
      sc = rtems_semaphore_obtain(                                    
40007414:	d0 07 60 68 	ld  [ %i5 + 0x68 ], %o0                        
40007418:	d2 07 60 6c 	ld  [ %i5 + 0x6c ], %o1                        
4000741c:	40 00 04 5c 	call  4000858c <rtems_semaphore_obtain>        
40007420:	94 10 00 1c 	mov  %i4, %o2                                  
        tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
      if (sc != RTEMS_SUCCESSFUL)                                     
40007424:	80 a2 20 00 	cmp  %o0, 0                                    
40007428:	02 bf ff b3 	be  400072f4 <rtems_termios_read+0x138>        <== ALWAYS TAKEN
4000742c:	80 a6 e0 00 	cmp  %i3, 0                                    
40007430:	30 bf ff 85 	b,a   40007244 <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);                                              
40007434:	7f ff ff 1b 	call  400070a0 <siproc>                        <== NOT EXECUTED
40007438:	01 00 00 00 	nop                                            <== NOT EXECUTED
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
4000743c:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      <== NOT EXECUTED
40007440:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        <== NOT EXECUTED
40007444:	80 a0 80 01 	cmp  %g2, %g1                                  <== NOT EXECUTED
40007448:	06 bf ff e5 	bl  400073dc <rtems_termios_read+0x220>        <== NOT EXECUTED
4000744c:	01 00 00 00 	nop                                            <== NOT EXECUTED
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
        if (siproc (c, tty))                                          
          wait = 0;                                                   
40007450:	10 bf ff e3 	b  400073dc <rtems_termios_read+0x220>         <== NOT EXECUTED
40007454:	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)                     
40007458:	80 a0 60 00 	cmp  %g1, 0                                    <== NOT EXECUTED
4000745c:	22 80 00 07 	be,a   40007478 <rtems_termios_read+0x2bc>     <== NOT EXECUTED
40007460:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
          || (tty->flow_ctrl & FL_OSTOP))) {                          
40007464:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
40007468:	80 88 60 20 	btst  0x20, %g1                                <== NOT EXECUTED
4000746c:	02 bf ff c5 	be  40007380 <rtems_termios_read+0x1c4>        <== NOT EXECUTED
40007470:	01 00 00 00 	nop                                            <== NOT EXECUTED
          /* XON should be sent now... */                             
          (*tty->device.write)(                                       
40007474:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        <== NOT EXECUTED
40007478:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        <== NOT EXECUTED
4000747c:	92 10 00 13 	mov  %l3, %o1                                  <== NOT EXECUTED
40007480:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40007484:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
          }                                                           
        }                                                             
      }                                                               
                                                                      
      /* continue processing new character */                         
      if (tty->termios.c_lflag & ICANON) {                            
40007488:	10 bf ff cc 	b  400073b8 <rtems_termios_read+0x1fc>         <== NOT EXECUTED
4000748c:	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) {                                
40007490:	80 88 a0 02 	btst  2, %g2                                   
40007494:	02 80 00 0e 	be  400074cc <rtems_termios_read+0x310>        
40007498:	01 00 00 00 	nop                                            
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
4000749c:	9f c0 40 00 	call  %g1                                      
400074a0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
      if (n < 0) {                                                    
400074a4:	80 a2 20 00 	cmp  %o0, 0                                    
400074a8:	06 80 00 3a 	bl  40007590 <rtems_termios_read+0x3d4>        
400074ac:	90 0a 20 ff 	and  %o0, 0xff, %o0                            
        rtems_task_wake_after (1);                                    
      } else {                                                        
        if  (siproc (n, tty))                                         
400074b0:	7f ff fe fc 	call  400070a0 <siproc>                        
400074b4:	92 10 00 1d 	mov  %i5, %o1                                  
400074b8:	80 a2 20 00 	cmp  %o0, 0                                    
400074bc:	12 bf ff 62 	bne  40007244 <rtems_termios_read+0x88>        
400074c0:	80 a6 e0 00 	cmp  %i3, 0                                    
400074c4:	10 bf ff f6 	b  4000749c <rtems_termios_read+0x2e0>         
400074c8:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
      }                                                               
    }                                                                 
  } else {                                                            
    rtems_interval then, now;                                         
                                                                      
    then = rtems_clock_get_ticks_since_boot();                        
400074cc:	40 00 02 70 	call  40007e8c <rtems_clock_get_ticks_since_boot>
400074d0:	01 00 00 00 	nop                                            
400074d4:	b8 10 00 08 	mov  %o0, %i4                                  
    for (;;) {                                                        
      n = (*tty->device.pollRead)(tty->minor);                        
400074d8:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
400074dc:	9f c0 40 00 	call  %g1                                      
400074e0:	d0 07 60 10 	ld  [ %i5 + 0x10 ], %o0                        
      if (n < 0) {                                                    
400074e4:	80 a2 20 00 	cmp  %o0, 0                                    
400074e8:	06 80 00 10 	bl  40007528 <rtems_termios_read+0x36c>        
400074ec:	90 0a 20 ff 	and  %o0, 0xff, %o0                            
            break;                                                    
          }                                                           
        }                                                             
        rtems_task_wake_after (1);                                    
      } else {                                                        
        siproc (n, tty);                                              
400074f0:	7f ff fe ec 	call  400070a0 <siproc>                        
400074f4:	92 10 00 1d 	mov  %i5, %o1                                  
        if (tty->ccount >= tty->termios.c_cc[VMIN])                   
400074f8:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      
400074fc:	c4 07 60 20 	ld  [ %i5 + 0x20 ], %g2                        
40007500:	80 a0 80 01 	cmp  %g2, %g1                                  
40007504:	16 bf ff 4f 	bge  40007240 <rtems_termios_read+0x84>        
40007508:	80 a0 60 00 	cmp  %g1, 0                                    
          break;                                                      
        if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])      
4000750c:	22 bf ff f4 	be,a   400074dc <rtems_termios_read+0x320>     <== NEVER TAKEN
40007510:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        <== NOT EXECUTED
40007514:	c2 0f 60 46 	ldub  [ %i5 + 0x46 ], %g1                      
40007518:	80 a0 60 00 	cmp  %g1, 0                                    
4000751c:	22 bf ff f0 	be,a   400074dc <rtems_termios_read+0x320>     <== NEVER TAKEN
40007520:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        <== NOT EXECUTED
40007524:	30 bf ff ea 	b,a   400074cc <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]) {                                
40007528:	c2 0f 60 47 	ldub  [ %i5 + 0x47 ], %g1                      
4000752c:	80 a0 60 00 	cmp  %g1, 0                                    
40007530:	02 80 00 0d 	be  40007564 <rtems_termios_read+0x3a8>        
40007534:	c2 0f 60 46 	ldub  [ %i5 + 0x46 ], %g1                      
          if (tty->termios.c_cc[VTIME] && tty->ccount) {              
40007538:	80 a0 60 00 	cmp  %g1, 0                                    
4000753c:	02 80 00 06 	be  40007554 <rtems_termios_read+0x398>        <== NEVER TAKEN
40007540:	01 00 00 00 	nop                                            
40007544:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
40007548:	80 a0 60 00 	cmp  %g1, 0                                    
4000754c:	12 80 00 09 	bne  40007570 <rtems_termios_read+0x3b4>       
40007550:	01 00 00 00 	nop                                            
          now = rtems_clock_get_ticks_since_boot();                   
          if ((now - then) > tty->vtimeTicks) {                       
            break;                                                    
          }                                                           
        }                                                             
        rtems_task_wake_after (1);                                    
40007554:	40 00 05 5f 	call  40008ad0 <rtems_task_wake_after>         
40007558:	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);                        
4000755c:	10 bf ff e0 	b  400074dc <rtems_termios_read+0x320>         
40007560:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
            if ((now - then) > tty->vtimeTicks) {                     
              break;                                                  
            }                                                         
          }                                                           
        } else {                                                      
          if (!tty->termios.c_cc[VTIME])                              
40007564:	80 a0 60 00 	cmp  %g1, 0                                    
40007568:	02 bf ff 37 	be  40007244 <rtems_termios_read+0x88>         <== NEVER TAKEN
4000756c:	80 a6 e0 00 	cmp  %i3, 0                                    
            break;                                                    
          now = rtems_clock_get_ticks_since_boot();                   
40007570:	40 00 02 47 	call  40007e8c <rtems_clock_get_ticks_since_boot>
40007574:	01 00 00 00 	nop                                            
          if ((now - then) > tty->vtimeTicks) {                       
40007578:	c2 07 60 54 	ld  [ %i5 + 0x54 ], %g1                        
4000757c:	90 22 00 1c 	sub  %o0, %i4, %o0                             
40007580:	80 a2 00 01 	cmp  %o0, %g1                                  
40007584:	08 bf ff f4 	bleu  40007554 <rtems_termios_read+0x398>      
40007588:	80 a6 e0 00 	cmp  %i3, 0                                    
4000758c:	30 bf ff 2e 	b,a   40007244 <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);                                    
40007590:	40 00 05 50 	call  40008ad0 <rtems_task_wake_after>         
40007594:	90 10 20 01 	mov  1, %o0                                    
40007598:	10 bf ff c1 	b  4000749c <rtems_termios_read+0x2e0>         
4000759c:	c2 07 60 a0 	ld  [ %i5 + 0xa0 ], %g1                        
                                                                      

40005b58 <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) {
40005b58:	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))         
40005b5c:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        
40005b60:	82 08 64 03 	and  %g1, 0x403, %g1                           
40005b64:	80 a0 64 01 	cmp  %g1, 0x401                                
40005b68:	02 80 00 44 	be  40005c78 <rtems_termios_refill_transmitter+0x120><== NEVER TAKEN
40005b6c:	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) {
40005b70:	c2 06 20 b8 	ld  [ %i0 + 0xb8 ], %g1                        
40005b74:	82 08 60 03 	and  %g1, 3, %g1                               
40005b78:	80 a0 60 02 	cmp  %g1, 2                                    
40005b7c:	22 80 00 50 	be,a   40005cbc <rtems_termios_refill_transmitter+0x164><== NEVER TAKEN
40005b80:	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 ) {               
40005b84:	c4 06 20 80 	ld  [ %i0 + 0x80 ], %g2                        
40005b88:	c2 06 20 84 	ld  [ %i0 + 0x84 ], %g1                        
40005b8c:	80 a0 80 01 	cmp  %g2, %g1                                  
40005b90:	22 80 00 30 	be,a   40005c50 <rtems_termios_refill_transmitter+0xf8>
40005b94:	c2 06 20 94 	ld  [ %i0 + 0x94 ], %g1                        
        rtems_semaphore_release (tty->rawOutBuf.Semaphore);           
      }                                                               
      return 0;                                                       
    }                                                                 
                                                                      
    rtems_interrupt_disable(level);                                   
40005b98:	7f ff f2 4e 	call  400024d0 <sparc_disable_interrupts>      
40005b9c:	01 00 00 00 	nop                                            
    len = tty->t_dqlen;                                               
40005ba0:	f8 06 20 90 	ld  [ %i0 + 0x90 ], %i4                        
    tty->t_dqlen = 0;                                                 
40005ba4:	c0 26 20 90 	clr  [ %i0 + 0x90 ]                            
    rtems_interrupt_enable(level);                                    
40005ba8:	7f ff f2 4e 	call  400024e0 <sparc_enable_interrupts>       
40005bac:	01 00 00 00 	nop                                            
                                                                      
    newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;      
40005bb0:	d0 06 20 84 	ld  [ %i0 + 0x84 ], %o0                        
40005bb4:	d2 06 20 88 	ld  [ %i0 + 0x88 ], %o1                        
40005bb8:	40 00 50 5b 	call  40019d24 <.urem>                         
40005bbc:	90 07 00 08 	add  %i4, %o0, %o0                             
    tty->rawOutBuf.Tail = newTail;                                    
    if (tty->rawOutBufState == rob_wait) {                            
40005bc0:	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;                                    
40005bc4:	d0 27 60 84 	st  %o0, [ %i5 + 0x84 ]                        
    if (tty->rawOutBufState == rob_wait) {                            
40005bc8:	80 a0 60 02 	cmp  %g1, 2                                    
40005bcc:	02 80 00 55 	be  40005d20 <rtems_termios_refill_transmitter+0x1c8>
40005bd0:	b8 10 00 08 	mov  %o0, %i4                                  
       * wake up any pending writer task                              
       */                                                             
      rtems_semaphore_release (tty->rawOutBuf.Semaphore);             
    }                                                                 
                                                                      
    if (newTail == tty->rawOutBuf.Head) {                             
40005bd4:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
40005bd8:	80 a0 40 1c 	cmp  %g1, %i4                                  
40005bdc:	22 80 00 48 	be,a   40005cfc <rtems_termios_refill_transmitter+0x1a4>
40005be0:	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))               
40005be4:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40005be8:	82 08 62 10 	and  %g1, 0x210, %g1                           
40005bec:	80 a0 62 10 	cmp  %g1, 0x210                                
40005bf0:	02 80 00 4f 	be  40005d2c <rtems_termios_refill_transmitter+0x1d4><== NEVER TAKEN
40005bf4:	01 00 00 00 	nop                                            
      nToSend = 0;                                                    
    } else {                                                          
      /*                                                              
       * Buffer not empty, start tranmitter                           
       */                                                             
      if (newTail > tty->rawOutBuf.Head)                              
40005bf8:	c2 07 60 80 	ld  [ %i5 + 0x80 ], %g1                        
40005bfc:	80 a7 00 01 	cmp  %i4, %g1                                  
40005c00:	18 80 00 1b 	bgu  40005c6c <rtems_termios_refill_transmitter+0x114>
40005c04:	01 00 00 00 	nop                                            
        nToSend = tty->rawOutBuf.Size - newTail;                      
      else                                                            
        nToSend = tty->rawOutBuf.Head - newTail;                      
40005c08:	f0 07 60 80 	ld  [ %i5 + 0x80 ], %i0                        
40005c0c:	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)) {                   
40005c10:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        
40005c14:	80 88 66 00 	btst  0x600, %g1                               
40005c18:	02 80 00 04 	be  40005c28 <rtems_termios_refill_transmitter+0xd0>
40005c1c:	94 10 00 18 	mov  %i0, %o2                                  
40005c20:	94 10 20 01 	mov  1, %o2                                    
        nToSend = 1;                                                  
40005c24:	b0 10 20 01 	mov  1, %i0                                    
      }                                                               
      tty->rawOutBufState = rob_busy; /*apm*/                         
      (*tty->device.write)(                                           
40005c28:	d2 07 60 7c 	ld  [ %i5 + 0x7c ], %o1                        
40005c2c:	c2 07 60 a4 	ld  [ %i5 + 0xa4 ], %g1                        
40005c30:	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*/                         
40005c34:	84 10 20 01 	mov  1, %g2                                    
      (*tty->device.write)(                                           
40005c38:	92 02 40 1c 	add  %o1, %i4, %o1                             
40005c3c:	9f c0 40 00 	call  %g1                                      
40005c40:	c4 27 60 94 	st  %g2, [ %i5 + 0x94 ]                        
        tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);        
    }                                                                 
    tty->rawOutBuf.Tail = newTail; /*apm*/                            
40005c44:	f8 27 60 84 	st  %i4, [ %i5 + 0x84 ]                        
  }                                                                   
  return nToSend;                                                     
}                                                                     
40005c48:	81 c7 e0 08 	ret                                            
40005c4c:	81 e8 00 00 	restore                                        
  } else {                                                            
    if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {               
      /*                                                              
       * buffer was empty                                             
       */                                                             
      if (tty->rawOutBufState == rob_wait) {                          
40005c50:	80 a0 60 02 	cmp  %g1, 2                                    
40005c54:	12 bf ff fd 	bne  40005c48 <rtems_termios_refill_transmitter+0xf0><== ALWAYS TAKEN
40005c58:	b0 10 20 00 	clr  %i0                                       
        /*                                                            
         * this should never happen...                                
         */                                                           
        rtems_semaphore_release (tty->rawOutBuf.Semaphore);           
40005c5c:	40 00 0a 9b 	call  400086c8 <rtems_semaphore_release>       <== NOT EXECUTED
40005c60:	d0 07 60 8c 	ld  [ %i5 + 0x8c ], %o0                        <== NOT EXECUTED
40005c64:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005c68:	81 e8 00 00 	restore                                        <== NOT EXECUTED
    } else {                                                          
      /*                                                              
       * Buffer not empty, start tranmitter                           
       */                                                             
      if (newTail > tty->rawOutBuf.Head)                              
        nToSend = tty->rawOutBuf.Size - newTail;                      
40005c6c:	f0 07 60 88 	ld  [ %i5 + 0x88 ], %i0                        
40005c70:	10 bf ff e8 	b  40005c10 <rtems_termios_refill_transmitter+0xb8>
40005c74:	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);
40005c78:	c2 06 20 a4 	ld  [ %i0 + 0xa4 ], %g1                        <== NOT EXECUTED
40005c7c:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
40005c80:	92 06 20 4a 	add  %i0, 0x4a, %o1                            <== NOT EXECUTED
40005c84:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40005c88:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
                                                                      
    rtems_interrupt_disable(level);                                   
40005c8c:	7f ff f2 11 	call  400024d0 <sparc_disable_interrupts>      <== NOT EXECUTED
40005c90:	01 00 00 00 	nop                                            <== NOT EXECUTED
    tty->t_dqlen--;                                                   
40005c94:	c4 06 20 90 	ld  [ %i0 + 0x90 ], %g2                        <== NOT EXECUTED
    tty->flow_ctrl |= FL_ISNTXOF;                                     
40005c98:	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--;                                                   
40005c9c:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
    tty->flow_ctrl |= FL_ISNTXOF;                                     
40005ca0:	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--;                                                   
40005ca4:	c4 27 60 90 	st  %g2, [ %i5 + 0x90 ]                        <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
40005ca8:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
40005cac:	7f ff f2 0d 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40005cb0:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
40005cb4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005cb8:	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);
40005cbc:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
40005cc0:	92 06 20 49 	add  %i0, 0x49, %o1                            <== NOT EXECUTED
40005cc4:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40005cc8:	94 10 20 01 	mov  1, %o2                                    <== NOT EXECUTED
                                                                      
    rtems_interrupt_disable(level);                                   
40005ccc:	7f ff f2 01 	call  400024d0 <sparc_disable_interrupts>      <== NOT EXECUTED
40005cd0:	01 00 00 00 	nop                                            <== NOT EXECUTED
    tty->t_dqlen--;                                                   
40005cd4:	c4 06 20 90 	ld  [ %i0 + 0x90 ], %g2                        <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
40005cd8:	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--;                                                   
40005cdc:	84 00 bf ff 	add  %g2, -1, %g2                              <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
40005ce0:	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--;                                                   
40005ce4:	c4 27 60 90 	st  %g2, [ %i5 + 0x90 ]                        <== NOT EXECUTED
    tty->flow_ctrl &= ~FL_ISNTXOF;                                    
40005ce8:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
    rtems_interrupt_enable(level);                                    
40005cec:	7f ff f1 fd 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40005cf0:	b0 10 20 01 	mov  1, %i0                                    <== NOT EXECUTED
40005cf4:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40005cf8:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      
    if (newTail == tty->rawOutBuf.Head) {                             
      /*                                                              
       * Buffer has become empty                                      
       */                                                             
      tty->rawOutBufState = rob_idle;                                 
40005cfc:	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) {                             
40005d00:	80 a0 60 00 	cmp  %g1, 0                                    
40005d04:	02 bf ff d0 	be  40005c44 <rtems_termios_refill_transmitter+0xec><== ALWAYS TAKEN
40005d08:	b0 10 20 00 	clr  %i0                                       
        (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);   
40005d0c:	d2 07 60 d8 	ld  [ %i5 + 0xd8 ], %o1                        <== NOT EXECUTED
40005d10:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40005d14:	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*/                            
40005d18:	f8 27 60 84 	st  %i4, [ %i5 + 0x84 ]                        <== NOT EXECUTED
40005d1c:	30 bf ff f6 	b,a   40005cf4 <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);             
40005d20:	40 00 0a 6a 	call  400086c8 <rtems_semaphore_release>       
40005d24:	d0 06 20 8c 	ld  [ %i0 + 0x8c ], %o0                        
40005d28:	30 bf ff ab 	b,a   40005bd4 <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);                                 
40005d2c:	7f ff f1 e9 	call  400024d0 <sparc_disable_interrupts>      <== NOT EXECUTED
40005d30:	01 00 00 00 	nop                                            <== NOT EXECUTED
      tty->flow_ctrl |= FL_OSTOP;                                     
40005d34:	c2 07 60 b8 	ld  [ %i5 + 0xb8 ], %g1                        <== NOT EXECUTED
      tty->rawOutBufState = rob_busy; /*apm*/                         
40005d38:	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;                                     
40005d3c:	82 10 60 20 	or  %g1, 0x20, %g1                             <== NOT EXECUTED
      tty->rawOutBufState = rob_busy; /*apm*/                         
40005d40:	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;                                     
40005d44:	c2 27 60 b8 	st  %g1, [ %i5 + 0xb8 ]                        <== NOT EXECUTED
      tty->rawOutBufState = rob_busy; /*apm*/                         
      rtems_interrupt_enable(level);                                  
40005d48:	7f ff f1 e6 	call  400024e0 <sparc_enable_interrupts>       <== NOT EXECUTED
40005d4c:	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*/                            
40005d50:	f8 27 60 84 	st  %i4, [ %i5 + 0x84 ]                        <== NOT EXECUTED
40005d54:	30 bf ff e8 	b,a   40005cf4 <rtems_termios_refill_transmitter+0x19c><== NOT EXECUTED
                                                                      

400078d8 <rtems_termios_rxdaemon>: /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) {
400078d8:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
400078dc:	10 80 00 08 	b  400078fc <rtems_termios_rxdaemon+0x24>      
400078e0:	96 07 bf fc 	add  %fp, -4, %o3                              
    }                                                                 
                                                                      
    /*                                                                
     * do something                                                   
     */                                                               
    c = tty->device.pollRead(tty->minor);                             
400078e4:	9f c0 40 00 	call  %g1                                      
400078e8:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        
    if (c != EOF) {                                                   
400078ec:	80 a2 3f ff 	cmp  %o0, -1                                   
400078f0:	32 80 00 15 	bne,a   40007944 <rtems_termios_rxdaemon+0x6c> 
400078f4:	d0 2f bf fb 	stb  %o0, [ %fp + -5 ]                         
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
400078f8:	96 07 bf fc 	add  %fp, -4, %o3                              
400078fc:	92 10 20 02 	mov  2, %o1                                    
40007900:	94 10 20 00 	clr  %o2                                       
40007904:	40 00 01 85 	call  40007f18 <rtems_event_receive>           
40007908:	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) {              
4000790c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40007910:	80 88 60 01 	btst  1, %g1                                   
40007914:	22 bf ff f4 	be,a   400078e4 <rtems_termios_rxdaemon+0xc>   <== ALWAYS TAKEN
40007918:	c2 06 20 a0 	ld  [ %i0 + 0xa0 ], %g1                        
      tty->rxTaskId = 0;                                              
4000791c:	c0 26 20 c4 	clr  [ %i0 + 0xc4 ]                            <== NOT EXECUTED
      rtems_task_delete(RTEMS_SELF);                                  
40007920:	40 00 03 f3 	call  400088ec <rtems_task_delete>             <== NOT EXECUTED
40007924:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * do something                                                   
     */                                                               
    c = tty->device.pollRead(tty->minor);                             
40007928:	c2 06 20 a0 	ld  [ %i0 + 0xa0 ], %g1                        <== NOT EXECUTED
4000792c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40007930:	d0 06 20 10 	ld  [ %i0 + 0x10 ], %o0                        <== NOT EXECUTED
    if (c != EOF) {                                                   
40007934:	80 a2 3f ff 	cmp  %o0, -1                                   <== NOT EXECUTED
40007938:	22 bf ff f1 	be,a   400078fc <rtems_termios_rxdaemon+0x24>  <== NOT EXECUTED
4000793c:	96 07 bf fc 	add  %fp, -4, %o3                              <== NOT EXECUTED
      /*                                                              
       * pollRead did call enqueue on its own                         
       */                                                             
      c_buf = c;                                                      
40007940:	d0 2f bf fb 	stb  %o0, [ %fp + -5 ]                         <== NOT EXECUTED
      rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);           
40007944:	92 07 bf fb 	add  %fp, -5, %o1                              
40007948:	90 10 00 18 	mov  %i0, %o0                                  
4000794c:	7f ff ff 1a 	call  400075b4 <rtems_termios_enqueue_raw_characters>
40007950:	94 10 20 01 	mov  1, %o2                                    
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
40007954:	10 bf ff ea 	b  400078fc <rtems_termios_rxdaemon+0x24>      
40007958:	96 07 bf fc 	add  %fp, -4, %o3                              
                                                                      

40005d58 <rtems_termios_txdaemon>: /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) {
40005d58:	9d e3 bf 98 	save  %sp, -104, %sp                           
40005d5c:	3b 10 00 7f 	sethi  %hi(0x4001fc00), %i5                    
40005d60:	10 80 00 0c 	b  40005d90 <rtems_termios_txdaemon+0x38>      
40005d64:	ba 17 61 34 	or  %i5, 0x134, %i5	! 4001fd34 <rtems_termios_linesw>
    }                                                                 
                                                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
40005d68:	83 28 60 05 	sll  %g1, 5, %g1                               
40005d6c:	82 07 40 01 	add  %i5, %g1, %g1                             
40005d70:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
40005d74:	80 a0 60 00 	cmp  %g1, 0                                    
40005d78:	02 80 00 04 	be  40005d88 <rtems_termios_txdaemon+0x30>     <== ALWAYS TAKEN
40005d7c:	90 10 00 18 	mov  %i0, %o0                                  
      rtems_termios_linesw[tty->t_line].l_start(tty);                 
40005d80:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
40005d84:	01 00 00 00 	nop                                            <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * try to push further characters to device                       
     */                                                               
    rtems_termios_refill_transmitter(tty);                            
40005d88:	7f ff ff 74 	call  40005b58 <rtems_termios_refill_transmitter>
40005d8c:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  while (1) {                                                         
    /*                                                                
     * wait for rtems event                                           
     */                                                               
    rtems_event_receive(                                              
40005d90:	92 10 20 02 	mov  2, %o1                                    
40005d94:	94 10 20 00 	clr  %o2                                       
40005d98:	96 07 bf fc 	add  %fp, -4, %o3                              
40005d9c:	40 00 08 5f 	call  40007f18 <rtems_event_receive>           
40005da0:	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) {              
40005da4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40005da8:	80 88 60 01 	btst  1, %g1                                   
40005dac:	22 bf ff ef 	be,a   40005d68 <rtems_termios_txdaemon+0x10>  <== ALWAYS TAKEN
40005db0:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        
      tty->txTaskId = 0;                                              
40005db4:	c0 26 20 c8 	clr  [ %i0 + 0xc8 ]                            <== NOT EXECUTED
      rtems_task_delete(RTEMS_SELF);                                  
40005db8:	40 00 0a cd 	call  400088ec <rtems_task_delete>             <== NOT EXECUTED
40005dbc:	90 10 20 00 	clr  %o0                                       <== NOT EXECUTED
    }                                                                 
                                                                      
    /*                                                                
     * call any line discipline start function                        
     */                                                               
    if (rtems_termios_linesw[tty->t_line].l_start != NULL) {          
40005dc0:	10 bf ff ea 	b  40005d68 <rtems_termios_txdaemon+0x10>      <== NOT EXECUTED
40005dc4:	c2 06 20 cc 	ld  [ %i0 + 0xcc ], %g1                        <== NOT EXECUTED
                                                                      

400070e8 <rtems_termios_write>: rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) {
400070e8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_rw_args_t *args = arg;                                  
  struct rtems_termios_tty *tty = args->iop->data1;                   
400070ec:	c2 06 00 00 	ld  [ %i0 ], %g1                               
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400070f0:	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;                   
400070f4:	fa 00 60 30 	ld  [ %g1 + 0x30 ], %i5                        
  rtems_status_code sc;                                               
                                                                      
  sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400070f8:	94 10 20 00 	clr  %o2                                       
400070fc:	40 00 05 24 	call  4000858c <rtems_semaphore_obtain>        
40007100:	d0 07 60 18 	ld  [ %i5 + 0x18 ], %o0                        
  if (sc != RTEMS_SUCCESSFUL)                                         
40007104:	b4 92 20 00 	orcc  %o0, 0, %i2                              
40007108:	12 80 00 0f 	bne  40007144 <rtems_termios_write+0x5c>       <== NEVER TAKEN
4000710c:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
    return sc;                                                        
  if (rtems_termios_linesw[tty->t_line].l_write != NULL) {            
40007110:	c4 07 60 cc 	ld  [ %i5 + 0xcc ], %g2                        
40007114:	85 28 a0 05 	sll  %g2, 5, %g2                               
40007118:	82 10 61 34 	or  %g1, 0x134, %g1                            
4000711c:	82 00 40 02 	add  %g1, %g2, %g1                             
40007120:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40007124:	80 a0 60 00 	cmp  %g1, 0                                    
40007128:	02 80 00 09 	be  4000714c <rtems_termios_write+0x64>        
4000712c:	90 10 00 1d 	mov  %i5, %o0                                  
    sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);         
40007130:	9f c0 40 00 	call  %g1                                      
40007134:	92 10 00 18 	mov  %i0, %o1                                  
40007138:	b4 10 00 08 	mov  %o0, %i2                                  
    rtems_semaphore_release (tty->osem);                              
4000713c:	40 00 05 63 	call  400086c8 <rtems_semaphore_release>       
40007140:	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;                                                          
}                                                                     
40007144:	81 c7 e0 08 	ret                                            
40007148:	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) {                                 
4000714c:	c2 07 60 34 	ld  [ %i5 + 0x34 ], %g1                        
40007150:	80 88 60 01 	btst  1, %g1                                   
40007154:	22 80 00 14 	be,a   400071a4 <rtems_termios_write+0xbc>     <== NEVER TAKEN
40007158:	d0 1e 20 10 	ldd  [ %i0 + 0x10 ], %o0                       <== NOT EXECUTED
    uint32_t   count = args->count;                                   
4000715c:	f8 06 20 14 	ld  [ %i0 + 0x14 ], %i4                        
    char      *buffer = args->buffer;                                 
    while (count--)                                                   
40007160:	80 a7 20 00 	cmp  %i4, 0                                    
40007164:	02 80 00 14 	be  400071b4 <rtems_termios_write+0xcc>        <== NEVER TAKEN
40007168:	f6 06 20 10 	ld  [ %i0 + 0x10 ], %i3                        
      oproc (*buffer++, tty);                                         
4000716c:	d0 0e c0 00 	ldub  [ %i3 ], %o0                             
40007170:	92 10 00 1d 	mov  %i5, %o1                                  
40007174:	7f ff fe 3e 	call  40006a6c <oproc>                         
40007178:	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--)                                                   
4000717c:	b8 87 3f ff 	addcc  %i4, -1, %i4                            
40007180:	12 bf ff fb 	bne  4000716c <rtems_termios_write+0x84>       
40007184:	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;                                  
40007188:	c2 06 20 14 	ld  [ %i0 + 0x14 ], %g1                        
  }                                                                   
  rtems_semaphore_release (tty->osem);                                
4000718c:	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;                                  
40007190:	c2 26 20 1c 	st  %g1, [ %i0 + 0x1c ]                        
  }                                                                   
  rtems_semaphore_release (tty->osem);                                
40007194:	40 00 05 4d 	call  400086c8 <rtems_semaphore_release>       
40007198:	b0 10 00 1a 	mov  %i2, %i0                                  
  return sc;                                                          
}                                                                     
4000719c:	81 c7 e0 08 	ret                                            
400071a0:	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);              
400071a4:	7f ff fd e2 	call  4000692c <rtems_termios_puts>            <== NOT EXECUTED
400071a8:	94 10 00 1d 	mov  %i5, %o2                                  <== NOT EXECUTED
    args->bytes_moved = args->count;                                  
400071ac:	10 bf ff f8 	b  4000718c <rtems_termios_write+0xa4>         <== NOT EXECUTED
400071b0:	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--)                                                   
400071b4:	10 bf ff f6 	b  4000718c <rtems_termios_write+0xa4>         <== NOT EXECUTED
400071b8:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
                                                                      

4001827c <rtems_timer_cancel>: */ rtems_status_code rtems_timer_cancel( rtems_id id ) {
4001827c:	9d e3 bf 98 	save  %sp, -104, %sp                           
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (                      
  Objects_Id         id,                                              
  Objects_Locations *location                                         
)                                                                     
{                                                                     
  return (Timer_Control *)                                            
40018280:	11 10 00 fc 	sethi  %hi(0x4003f000), %o0                    
40018284:	92 10 00 18 	mov  %i0, %o1                                  
40018288:	90 12 21 c8 	or  %o0, 0x1c8, %o0                            
4001828c:	40 00 0c fe 	call  4001b684 <_Objects_Get>                  
40018290:	94 07 bf fc 	add  %fp, -4, %o2                              
  Timer_Control   *the_timer;                                         
  Objects_Locations       location;                                   
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
40018294:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40018298:	80 a0 60 00 	cmp  %g1, 0                                    
4001829c:	12 80 00 0c 	bne  400182cc <rtems_timer_cancel+0x50>        
400182a0:	01 00 00 00 	nop                                            
                                                                      
    case OBJECTS_LOCAL:                                               
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )         
400182a4:	c2 02 20 38 	ld  [ %o0 + 0x38 ], %g1                        
400182a8:	80 a0 60 04 	cmp  %g1, 4                                    
400182ac:	02 80 00 04 	be  400182bc <rtems_timer_cancel+0x40>         <== NEVER TAKEN
400182b0:	01 00 00 00 	nop                                            
        (void) _Watchdog_Remove( &the_timer->Ticker );                
400182b4:	40 00 14 ec 	call  4001d664 <_Watchdog_Remove>              
400182b8:	90 02 20 10 	add  %o0, 0x10, %o0                            
      _Thread_Enable_dispatch();                                      
400182bc:	40 00 10 d5 	call  4001c610 <_Thread_Enable_dispatch>       
400182c0:	b0 10 20 00 	clr  %i0                                       
400182c4:	81 c7 e0 08 	ret                                            
400182c8:	81 e8 00 00 	restore                                        
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
400182cc:	81 c7 e0 08 	ret                                            
400182d0:	91 e8 20 04 	restore  %g0, 4, %o0                           
                                                                      

400187d4 <rtems_timer_server_fire_when>: rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) {
400187d4:	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;                 
400187d8:	03 10 00 fc 	sethi  %hi(0x4003f000), %g1                    
400187dc:	fa 00 62 08 	ld  [ %g1 + 0x208 ], %i5	! 4003f208 <_Timer_server>
                                                                      
  if ( !timer_server )                                                
400187e0:	80 a7 60 00 	cmp  %i5, 0                                    
400187e4:	02 80 00 08 	be  40018804 <rtems_timer_server_fire_when+0x30>
400187e8:	82 10 20 0e 	mov  0xe, %g1                                  
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD.is_set )                                                 
400187ec:	39 10 00 f9 	sethi  %hi(0x4003e400), %i4                    
400187f0:	82 17 23 a8 	or  %i4, 0x3a8, %g1	! 4003e7a8 <_TOD>          
400187f4:	c4 08 60 14 	ldub  [ %g1 + 0x14 ], %g2                      
400187f8:	80 a0 a0 00 	cmp  %g2, 0                                    
400187fc:	12 80 00 04 	bne  4001880c <rtems_timer_server_fire_when+0x38><== ALWAYS TAKEN
40018800:	82 10 20 0b 	mov  0xb, %g1                                  
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
40018804:	81 c7 e0 08 	ret                                            
40018808:	91 e8 00 01 	restore  %g0, %g1, %o0                         
    return RTEMS_INCORRECT_STATE;                                     
                                                                      
  if ( !_TOD.is_set )                                                 
    return RTEMS_NOT_DEFINED;                                         
                                                                      
  if ( !routine )                                                     
4001880c:	80 a6 a0 00 	cmp  %i2, 0                                    
40018810:	02 bf ff fd 	be  40018804 <rtems_timer_server_fire_when+0x30>
40018814:	82 10 20 09 	mov  9, %g1                                    
    return RTEMS_INVALID_ADDRESS;                                     
                                                                      
  if ( !_TOD_Validate( wall_time ) )                                  
40018818:	7f ff f3 1e 	call  40015490 <_TOD_Validate>                 
4001881c:	90 10 00 19 	mov  %i1, %o0                                  
40018820:	80 8a 20 ff 	btst  0xff, %o0                                
40018824:	12 80 00 04 	bne  40018834 <rtems_timer_server_fire_when+0x60>
40018828:	82 10 20 14 	mov  0x14, %g1                                 
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
}                                                                     
4001882c:	81 c7 e0 08 	ret                                            
40018830:	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 );                             
40018834:	7f ff f2 dd 	call  400153a8 <_TOD_To_seconds>               
40018838:	90 10 00 19 	mov  %i1, %o0                                  
4001883c:	b2 10 00 08 	mov  %o0, %i1                                  
40018840:	d0 1f 23 a8 	ldd  [ %i4 + 0x3a8 ], %o0                      
40018844:	94 10 20 00 	clr  %o2                                       
40018848:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
4001884c:	40 00 52 36 	call  4002d124 <__divdi3>                      
40018850:	96 12 e2 00 	or  %o3, 0x200, %o3	! 3b9aca00 <RAM_SIZE+0x3b5aca00>
  if ( seconds <= _TOD_Seconds_since_epoch() )                        
40018854:	80 a6 40 09 	cmp  %i1, %o1                                  
40018858:	08 bf ff f5 	bleu  4001882c <rtems_timer_server_fire_when+0x58>
4001885c:	82 10 20 14 	mov  0x14, %g1                                 
40018860:	92 10 00 18 	mov  %i0, %o1                                  
40018864:	11 10 00 fc 	sethi  %hi(0x4003f000), %o0                    
40018868:	94 07 bf fc 	add  %fp, -4, %o2                              
4001886c:	40 00 0b 86 	call  4001b684 <_Objects_Get>                  
40018870:	90 12 21 c8 	or  %o0, 0x1c8, %o0                            
    return RTEMS_INVALID_CLOCK;                                       
                                                                      
  the_timer = _Timer_Get( id, &location );                            
  switch ( location ) {                                               
40018874:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40018878:	80 a0 60 00 	cmp  %g1, 0                                    
4001887c:	12 80 00 19 	bne  400188e0 <rtems_timer_server_fire_when+0x10c>
40018880:	a0 10 00 08 	mov  %o0, %l0                                  
                                                                      
    case OBJECTS_LOCAL:                                               
      (void) _Watchdog_Remove( &the_timer->Ticker );                  
40018884:	40 00 13 78 	call  4001d664 <_Watchdog_Remove>              
40018888:	90 02 20 10 	add  %o0, 0x10, %o0                            
4001888c:	d0 1f 23 a8 	ldd  [ %i4 + 0x3a8 ], %o0                      
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;               
40018890:	82 10 20 03 	mov  3, %g1                                    
40018894:	94 10 20 00 	clr  %o2                                       
40018898:	c2 24 20 38 	st  %g1, [ %l0 + 0x38 ]                        
4001889c:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
400188a0:	c0 24 20 18 	clr  [ %l0 + 0x18 ]                            
400188a4:	96 12 e2 00 	or  %o3, 0x200, %o3                            
  the_watchdog->routine   = routine;                                  
400188a8:	f4 24 20 2c 	st  %i2, [ %l0 + 0x2c ]                        
  the_watchdog->id        = id;                                       
400188ac:	f0 24 20 30 	st  %i0, [ %l0 + 0x30 ]                        
400188b0:	40 00 52 1d 	call  4002d124 <__divdi3>                      
400188b4:	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 ); 
400188b8:	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();
400188bc:	b2 26 40 09 	sub  %i1, %o1, %i1                             
                                                                      
      (*timer_server->schedule_operation)( timer_server, the_timer ); 
400188c0:	90 10 00 1d 	mov  %i5, %o0                                  
400188c4:	92 10 00 10 	mov  %l0, %o1                                  
400188c8:	9f c0 40 00 	call  %g1                                      
400188cc:	f2 24 20 1c 	st  %i1, [ %l0 + 0x1c ]                        
                                                                      
      _Thread_Enable_dispatch();                                      
400188d0:	40 00 0f 50 	call  4001c610 <_Thread_Enable_dispatch>       
400188d4:	01 00 00 00 	nop                                            
      return RTEMS_SUCCESSFUL;                                        
400188d8:	10 bf ff cb 	b  40018804 <rtems_timer_server_fire_when+0x30>
400188dc:	82 10 20 00 	clr  %g1	! 0 <PROM_START>                      
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  return RTEMS_INVALID_ID;                                            
400188e0:	10 bf ff c9 	b  40018804 <rtems_timer_server_fire_when+0x30>
400188e4:	82 10 20 04 	mov  4, %g1                                    
                                                                      

40003fb8 <rtems_verror>: static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) {
40003fb8:	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) {                               
40003fbc:	03 08 00 00 	sethi  %hi(0x20000000), %g1                    
40003fc0:	80 8e 00 01 	btst  %i0, %g1                                 
40003fc4:	02 80 00 10 	be  40004004 <rtems_verror+0x4c>               
40003fc8:	b8 10 00 18 	mov  %i0, %i4                                  
    if (rtems_panic_in_progress++)                                    
40003fcc:	05 10 00 80 	sethi  %hi(0x40020000), %g2                    
40003fd0:	c6 00 a1 20 	ld  [ %g2 + 0x120 ], %g3	! 40020120 <rtems_panic_in_progress>
40003fd4:	82 00 e0 01 	add  %g3, 1, %g1                               
40003fd8:	80 a0 e0 00 	cmp  %g3, 0                                    
40003fdc:	02 80 00 07 	be  40003ff8 <rtems_verror+0x40>               <== ALWAYS TAKEN
40003fe0:	c2 20 a1 20 	st  %g1, [ %g2 + 0x120 ]                       
   *                                                                  
   * 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;                  
40003fe4:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    <== NOT EXECUTED
40003fe8:	c6 00 62 b0 	ld  [ %g1 + 0x2b0 ], %g3	! 400202b0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
                                                                      
    ++level;                                                          
40003fec:	86 00 e0 01 	inc  %g3                                       <== NOT EXECUTED
    _Thread_Dispatch_disable_level = level;                           
40003ff0:	c6 20 62 b0 	st  %g3, [ %g1 + 0x2b0 ]                       <== 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();                                    
40003ff4:	c2 00 a1 20 	ld  [ %g2 + 0x120 ], %g1                       <== NOT EXECUTED
      _Thread_Disable_dispatch();       /* disable task switches */   
                                                                      
    /* don't aggravate things */                                      
    if (rtems_panic_in_progress > 2)                                  
40003ff8:	80 a0 60 02 	cmp  %g1, 2                                    
40003ffc:	14 80 00 30 	bg  400040bc <rtems_verror+0x104>              <== NEVER TAKEN
40004000:	b0 10 20 00 	clr  %i0                                       
      return 0;                                                       
  }                                                                   
                                                                      
  (void) fflush(stdout);            /* in case stdout/stderr same */  
40004004:	3b 10 00 7d 	sethi  %hi(0x4001f400), %i5                    
40004008:	c2 07 63 68 	ld  [ %i5 + 0x368 ], %g1	! 4001f768 <_impure_ptr>
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
4000400c:	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 */  
40004010:	d0 00 60 08 	ld  [ %g1 + 8 ], %o0                           
40004014:	40 00 33 4e 	call  40010d4c <fflush>                        
40004018:	b6 2f 00 1b 	andn  %i4, %i3, %i3                            
                                                                      
  status = error_flag & ~RTEMS_ERROR_MASK;                            
  if (error_flag & RTEMS_ERROR_ERRNO)     /* include errno? */        
4000401c:	03 10 00 00 	sethi  %hi(0x40000000), %g1                    
40004020:	80 8f 00 01 	btst  %i4, %g1                                 
40004024:	12 80 00 34 	bne  400040f4 <rtems_verror+0x13c>             
40004028:	01 00 00 00 	nop                                            
  rtems_error_code_t  error_flag,                                     
  const char         *printf_format,                                  
  va_list             arglist                                         
)                                                                     
{                                                                     
  int               local_errno = 0;                                  
4000402c:	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);          
40004030:	c2 07 63 68 	ld  [ %i5 + 0x368 ], %g1                       
40004034:	92 10 00 19 	mov  %i1, %o1                                  
40004038:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
4000403c:	40 00 47 ba 	call  40015f24 <vfprintf>                      
40004040:	94 10 00 1a 	mov  %i2, %o2                                  
                                                                      
  if (status)                                                         
40004044:	80 a6 e0 00 	cmp  %i3, 0                                    
40004048:	12 80 00 1f 	bne  400040c4 <rtems_verror+0x10c>             
4000404c:	b0 10 00 08 	mov  %o0, %i0                                  
    chars_written +=                                                  
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
                                                                      
  if (local_errno) {                                                  
40004050:	80 a7 20 00 	cmp  %i4, 0                                    
40004054:	02 80 00 12 	be  4000409c <rtems_verror+0xe4>               
40004058:	c2 07 63 68 	ld  [ %i5 + 0x368 ], %g1                       
    if ((local_errno > 0) && *strerror(local_errno))                  
4000405c:	80 a7 20 00 	cmp  %i4, 0                                    
40004060:	04 80 00 09 	ble  40004084 <rtems_verror+0xcc>              
40004064:	13 10 00 76 	sethi  %hi(0x4001d800), %o1                    
40004068:	40 00 37 93 	call  40011eb4 <strerror>                      
4000406c:	90 10 00 1c 	mov  %i4, %o0                                  
40004070:	c2 4a 00 00 	ldsb  [ %o0 ], %g1                             
40004074:	80 a0 60 00 	cmp  %g1, 0                                    
40004078:	12 80 00 23 	bne  40004104 <rtems_verror+0x14c>             <== ALWAYS TAKEN
4000407c:	c2 07 63 68 	ld  [ %i5 + 0x368 ], %g1                       
      chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
    else                                                              
      chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
40004080:	13 10 00 76 	sethi  %hi(0x4001d800), %o1                    <== NOT EXECUTED
40004084:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
40004088:	92 12 62 48 	or  %o1, 0x248, %o1                            
4000408c:	40 00 34 2c 	call  4001113c <fprintf>                       
40004090:	94 10 00 1c 	mov  %i4, %o2                                  
40004094:	b0 06 00 08 	add  %i0, %o0, %i0                             
  }                                                                   
                                                                      
  chars_written += fprintf(stderr, "\n");                             
40004098:	c2 07 63 68 	ld  [ %i5 + 0x368 ], %g1                       
4000409c:	13 10 00 76 	sethi  %hi(0x4001d800), %o1                    
400040a0:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
400040a4:	40 00 34 26 	call  4001113c <fprintf>                       
400040a8:	92 12 62 60 	or  %o1, 0x260, %o1                            
                                                                      
  (void) fflush(stderr);                                              
400040ac:	c2 07 63 68 	ld  [ %i5 + 0x368 ], %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");                             
400040b0:	b0 02 00 18 	add  %o0, %i0, %i0                             
                                                                      
  (void) fflush(stderr);                                              
400040b4:	40 00 33 26 	call  40010d4c <fflush>                        
400040b8:	d0 00 60 0c 	ld  [ %g1 + 0xc ], %o0                         
                                                                      
  return chars_written;                                               
}                                                                     
400040bc:	81 c7 e0 08 	ret                                            
400040c0:	81 e8 00 00 	restore                                        
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
                                                                      
  if (status)                                                         
    chars_written +=                                                  
      fprintf(stderr, " (status: %s)", rtems_status_text(status));    
400040c4:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
400040c8:	c2 00 63 68 	ld  [ %g1 + 0x368 ], %g1	! 4001f768 <_impure_ptr>
400040cc:	90 10 00 1b 	mov  %i3, %o0                                  
400040d0:	7f ff ff b4 	call  40003fa0 <rtems_status_text>             
400040d4:	f6 00 60 0c 	ld  [ %g1 + 0xc ], %i3                         
400040d8:	13 10 00 76 	sethi  %hi(0x4001d800), %o1                    
400040dc:	94 10 00 08 	mov  %o0, %o2                                  
400040e0:	92 12 62 28 	or  %o1, 0x228, %o1                            
400040e4:	40 00 34 16 	call  4001113c <fprintf>                       
400040e8:	90 10 00 1b 	mov  %i3, %o0                                  
  #endif                                                              
                                                                      
  chars_written += vfprintf(stderr, printf_format, arglist);          
                                                                      
  if (status)                                                         
    chars_written +=                                                  
400040ec:	10 bf ff d9 	b  40004050 <rtems_verror+0x98>                
400040f0:	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;                                              
400040f4:	40 00 32 13 	call  40010940 <__errno>                       
400040f8:	01 00 00 00 	nop                                            
400040fc:	10 bf ff cd 	b  40004030 <rtems_verror+0x78>                
40004100:	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));
40004104:	90 10 00 1c 	mov  %i4, %o0                                  
40004108:	40 00 37 6b 	call  40011eb4 <strerror>                      
4000410c:	f8 00 60 0c 	ld  [ %g1 + 0xc ], %i4                         
40004110:	13 10 00 76 	sethi  %hi(0x4001d800), %o1                    
40004114:	94 10 00 08 	mov  %o0, %o2                                  
40004118:	92 12 62 38 	or  %o1, 0x238, %o1                            
4000411c:	40 00 34 08 	call  4001113c <fprintf>                       
40004120:	90 10 00 1c 	mov  %i4, %o0                                  
40004124:	10 bf ff dd 	b  40004098 <rtems_verror+0xe0>                
40004128:	b0 06 00 08 	add  %i0, %o0, %i0                             
                                                                      

40027efc <scanInt>: /** * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) {
40027efc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int c;                                                              
  unsigned int i = 0;                                                 
  unsigned int limit = INT_MAX;                                       
40027f00:	35 1f ff ff 	sethi  %hi(0x7ffffc00), %i2                    
  int sign = 0;                                                       
40027f04:	b6 10 20 00 	clr  %i3                                       
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
  int c;                                                              
  unsigned int i = 0;                                                 
  unsigned int limit = INT_MAX;                                       
40027f08:	b4 16 a3 ff 	or  %i2, 0x3ff, %i2                            
 */                                                                   
static int                                                            
scanInt(FILE *fp, int *val)                                           
{                                                                     
  int c;                                                              
  unsigned int i = 0;                                                 
40027f0c:	ba 10 20 00 	clr  %i5                                       
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40027f10:	23 10 01 97 	sethi  %hi(0x40065c00), %l1                    
        limit++;                                                      
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
40027f14:	21 10 01 97 	sethi  %hi(0x40065c00), %l0                    
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40027f18:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
40027f1c:	82 00 7f ff 	add  %g1, -1, %g1                              
40027f20:	80 a0 60 00 	cmp  %g1, 0                                    
40027f24:	06 80 00 26 	bl  40027fbc <scanInt+0xc0>                    <== NEVER TAKEN
40027f28:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
40027f2c:	c4 06 00 00 	ld  [ %i0 ], %g2                               
40027f30:	d0 08 80 00 	ldub  [ %g2 ], %o0                             
40027f34:	84 00 a0 01 	inc  %g2                                       
    if (c == ':')                                                     
40027f38:	80 a2 20 3a 	cmp  %o0, 0x3a                                 
40027f3c:	02 80 00 26 	be  40027fd4 <scanInt+0xd8>                    
40027f40:	c4 26 00 00 	st  %g2, [ %i0 ]                               
      break;                                                          
    if (sign == 0) {                                                  
40027f44:	80 a6 e0 00 	cmp  %i3, 0                                    
40027f48:	32 80 00 06 	bne,a   40027f60 <scanInt+0x64>                
40027f4c:	c4 04 21 b0 	ld  [ %l0 + 0x1b0 ], %g2                       
      if (c == '-') {                                                 
40027f50:	80 a2 20 2d 	cmp  %o0, 0x2d                                 
40027f54:	02 80 00 32 	be  4002801c <scanInt+0x120>                   
40027f58:	b6 10 20 01 	mov  1, %i3                                    
        limit++;                                                      
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
40027f5c:	c4 04 21 b0 	ld  [ %l0 + 0x1b0 ], %g2                       
40027f60:	84 00 80 08 	add  %g2, %o0, %g2                             
40027f64:	c4 08 a0 01 	ldub  [ %g2 + 1 ], %g2                         
40027f68:	80 88 a0 04 	btst  4, %g2                                   
40027f6c:	22 80 00 22 	be,a   40027ff4 <scanInt+0xf8>                 
40027f70:	b0 10 20 00 	clr  %i0                                       
      return 0;                                                       
    d = c - '0';                                                      
40027f74:	b8 02 3f d0 	add  %o0, -48, %i4                             
    if ((i > (limit / 10))                                            
40027f78:	92 10 20 0a 	mov  0xa, %o1                                  
40027f7c:	40 00 b8 b0 	call  4005623c <.udiv>                         
40027f80:	90 10 00 1a 	mov  %i2, %o0                                  
40027f84:	80 a7 40 08 	cmp  %i5, %o0                                  
40027f88:	38 80 00 1b 	bgu,a   40027ff4 <scanInt+0xf8>                
40027f8c:	b0 10 20 00 	clr  %i0                                       
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
40027f90:	02 80 00 1b 	be  40027ffc <scanInt+0x100>                   
40027f94:	90 10 00 1a 	mov  %i2, %o0                                  
      return 0;                                                       
    i = i * 10 + d;                                                   
40027f98:	83 2f 60 01 	sll  %i5, 1, %g1                               
40027f9c:	bb 2f 60 03 	sll  %i5, 3, %i5                               
40027fa0:	ba 00 40 1d 	add  %g1, %i5, %i5                             
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40027fa4:	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;                                                   
40027fa8:	ba 07 00 1d 	add  %i4, %i5, %i5                             
  unsigned int limit = INT_MAX;                                       
  int sign = 0;                                                       
  int d;                                                              
                                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40027fac:	82 00 7f ff 	add  %g1, -1, %g1                              
40027fb0:	80 a0 60 00 	cmp  %g1, 0                                    
40027fb4:	16 bf ff de 	bge  40027f2c <scanInt+0x30>                   <== ALWAYS TAKEN
40027fb8:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
40027fbc:	d0 04 61 c0 	ld  [ %l1 + 0x1c0 ], %o0                       <== NOT EXECUTED
40027fc0:	40 00 68 60 	call  40042140 <__srget_r>                     <== NOT EXECUTED
40027fc4:	92 10 00 18 	mov  %i0, %o1                                  <== NOT EXECUTED
    if (c == ':')                                                     
40027fc8:	80 a2 20 3a 	cmp  %o0, 0x3a                                 <== NOT EXECUTED
40027fcc:	12 bf ff df 	bne  40027f48 <scanInt+0x4c>                   <== NOT EXECUTED
40027fd0:	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)                                                      
40027fd4:	80 a6 e0 00 	cmp  %i3, 0                                    
40027fd8:	02 80 00 07 	be  40027ff4 <scanInt+0xf8>                    <== NEVER TAKEN
40027fdc:	b0 10 20 00 	clr  %i0                                       
    return 0;                                                         
  *val = i * sign;                                                    
40027fe0:	90 10 00 1b 	mov  %i3, %o0                                  
40027fe4:	92 10 00 1d 	mov  %i5, %o1                                  
40027fe8:	40 00 b8 5b 	call  40056154 <.umul>                         
40027fec:	b0 10 20 01 	mov  1, %i0                                    
40027ff0:	d0 26 40 00 	st  %o0, [ %i1 ]                               
  return 1;                                                           
40027ff4:	81 c7 e0 08 	ret                                            
40027ff8:	81 e8 00 00 	restore                                        
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
    d = c - '0';                                                      
    if ((i > (limit / 10))                                            
     || ((i == (limit / 10)) && (d > (limit % 10))))                  
40027ffc:	40 00 b9 3c 	call  400564ec <.urem>                         
40028000:	92 10 20 0a 	mov  0xa, %o1                                  
40028004:	80 a7 00 08 	cmp  %i4, %o0                                  
40028008:	08 bf ff e5 	bleu  40027f9c <scanInt+0xa0>                  <== NEVER TAKEN
4002800c:	83 2f 60 01 	sll  %i5, 1, %g1                               
        continue;                                                     
      }                                                               
      sign = 1;                                                       
    }                                                                 
    if (!isdigit(c))                                                  
      return 0;                                                       
40028010:	b0 10 20 00 	clr  %i0                                       
  }                                                                   
  if (sign == 0)                                                      
    return 0;                                                         
  *val = i * sign;                                                    
  return 1;                                                           
}                                                                     
40028014:	81 c7 e0 08 	ret                                            
40028018:	81 e8 00 00 	restore                                        
    if (c == ':')                                                     
      break;                                                          
    if (sign == 0) {                                                  
      if (c == '-') {                                                 
        sign = -1;                                                    
        limit++;                                                      
4002801c:	b4 06 a0 01 	inc  %i2                                       
        continue;                                                     
40028020:	10 bf ff be 	b  40027f18 <scanInt+0x1c>                     
40028024:	b6 10 3f ff 	mov  -1, %i3                                   
                                                                      

40028028 <scanString>: /** * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) {
40028028:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
4002802c:	c2 06 80 00 	ld  [ %i2 ], %g1                               
  for (;;) {                                                          
    c = getc(fp);                                                     
40028030:	3b 10 01 97 	sethi  %hi(0x40065c00), %i5                    
static int                                                            
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{                                                                     
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
40028034:	10 80 00 19 	b  40028098 <scanString+0x70>                  
40028038:	c2 26 40 00 	st  %g1, [ %i1 ]                               
  for (;;) {                                                          
    c = getc(fp);                                                     
4002803c:	c2 06 00 00 	ld  [ %i0 ], %g1                               
40028040:	d0 08 40 00 	ldub  [ %g1 ], %o0                             
40028044:	82 00 60 01 	inc  %g1                                       
    if (c == ':') {                                                   
40028048:	80 a2 20 3a 	cmp  %o0, 0x3a                                 
4002804c:	02 80 00 1e 	be  400280c4 <scanString+0x9c>                 
40028050:	c2 26 00 00 	st  %g1, [ %i0 ]                               
        if (nlFlag)                                                   
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == '\n') {                                                  
40028054:	80 a2 20 0a 	cmp  %o0, 0xa                                  
40028058:	02 80 00 2a 	be  40028100 <scanString+0xd8>                 
4002805c:	80 a2 3f ff 	cmp  %o0, -1                                   
        if (!nlFlag)                                                  
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == EOF)                                                     
40028060:	02 80 00 26 	be  400280f8 <scanString+0xd0>                 
40028064:	01 00 00 00 	nop                                            
      return 0;                                                       
    if (*nleft < 2)                                                   
40028068:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
4002806c:	80 a0 60 01 	cmp  %g1, 1                                    
40028070:	08 80 00 22 	bleu  400280f8 <scanString+0xd0>               
40028074:	01 00 00 00 	nop                                            
      return 0;                                                       
    **bufp = c;                                                       
40028078:	c2 06 80 00 	ld  [ %i2 ], %g1                               
4002807c:	d0 28 40 00 	stb  %o0, [ %g1 ]                              
    ++(*bufp);                                                        
40028080:	c4 06 80 00 	ld  [ %i2 ], %g2                               
    --(*nleft);                                                       
40028084:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
    if (c == EOF)                                                     
      return 0;                                                       
    if (*nleft < 2)                                                   
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
40028088:	84 00 a0 01 	inc  %g2                                       
4002808c:	c4 26 80 00 	st  %g2, [ %i2 ]                               
    --(*nleft);                                                       
40028090:	82 00 7f ff 	add  %g1, -1, %g1                              
40028094:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
{                                                                     
  int c;                                                              
                                                                      
  *name = *bufp;                                                      
  for (;;) {                                                          
    c = getc(fp);                                                     
40028098:	c2 06 20 04 	ld  [ %i0 + 4 ], %g1                           
4002809c:	82 00 7f ff 	add  %g1, -1, %g1                              
400280a0:	80 a0 60 00 	cmp  %g1, 0                                    
400280a4:	16 bf ff e6 	bge  4002803c <scanString+0x14>                
400280a8:	c2 26 20 04 	st  %g1, [ %i0 + 4 ]                           
400280ac:	d0 07 61 c0 	ld  [ %i5 + 0x1c0 ], %o0                       
400280b0:	40 00 68 24 	call  40042140 <__srget_r>                     
400280b4:	92 10 00 18 	mov  %i0, %o1                                  
    if (c == ':') {                                                   
400280b8:	80 a2 20 3a 	cmp  %o0, 0x3a                                 
400280bc:	12 bf ff e7 	bne  40028058 <scanString+0x30>                <== ALWAYS TAKEN
400280c0:	80 a2 20 0a 	cmp  %o0, 0xa                                  
        if (nlFlag)                                                   
400280c4:	80 a7 20 00 	cmp  %i4, 0                                    
400280c8:	12 80 00 11 	bne  4002810c <scanString+0xe4>                
400280cc:	b0 10 20 00 	clr  %i0                                       
      return 0;                                                       
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
400280d0:	c2 06 80 00 	ld  [ %i2 ], %g1                               
400280d4:	c0 28 40 00 	clrb  [ %g1 ]                                  
  ++(*bufp);                                                          
400280d8:	c4 06 80 00 	ld  [ %i2 ], %g2                               
  --(*nleft);                                                         
400280dc:	c2 06 c0 00 	ld  [ %i3 ], %g1                               
    **bufp = c;                                                       
    ++(*bufp);                                                        
    --(*nleft);                                                       
  }                                                                   
  **bufp = '\0';                                                      
  ++(*bufp);                                                          
400280e0:	84 00 a0 01 	inc  %g2                                       
400280e4:	c4 26 80 00 	st  %g2, [ %i2 ]                               
  --(*nleft);                                                         
400280e8:	82 00 7f ff 	add  %g1, -1, %g1                              
400280ec:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
  return 1;                                                           
400280f0:	81 c7 e0 08 	ret                                            
400280f4:	91 e8 20 01 	restore  %g0, 1, %o0                           
}                                                                     
400280f8:	81 c7 e0 08 	ret                                            
400280fc:	91 e8 20 00 	restore  %g0, 0, %o0                           
        if (nlFlag)                                                   
            return 0;                                                 
        break;                                                        
    }                                                                 
    if (c == '\n') {                                                  
        if (!nlFlag)                                                  
40028100:	80 a7 20 00 	cmp  %i4, 0                                    
40028104:	12 bf ff f3 	bne  400280d0 <scanString+0xa8>                
40028108:	b0 10 20 00 	clr  %i0                                       
4002810c:	81 c7 e0 08 	ret                                            
40028110:	81 e8 00 00 	restore                                        
                                                                      

40028114 <scangr>: FILE *fp, struct group *grp, char *buffer, size_t bufsize ) {
40028114:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
40028118:	98 10 20 00 	clr  %o4                                       
  FILE *fp,                                                           
  struct group *grp,                                                  
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
4002811c:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
40028120:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
  int grgid;                                                          
  char *grmem, *cp;                                                   
  int memcount;                                                       
                                                                      
  if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)            
40028124:	90 10 00 18 	mov  %i0, %o0                                  
40028128:	92 10 00 19 	mov  %i1, %o1                                  
4002812c:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40028130:	7f ff ff be 	call  40028028 <scanString>                    
40028134:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40028138:	80 a2 20 00 	cmp  %o0, 0                                    
4002813c:	12 80 00 04 	bne  4002814c <scangr+0x38>                    
40028140:	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;                                                         
40028144:	81 c7 e0 08 	ret                                            
40028148:	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)          
4002814c:	92 06 60 04 	add  %i1, 4, %o1                               
40028150:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40028154:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40028158:	7f ff ff b4 	call  40028028 <scanString>                    
4002815c:	98 10 20 00 	clr  %o4                                       
40028160:	80 a2 20 00 	cmp  %o0, 0                                    
40028164:	02 bf ff f8 	be  40028144 <scangr+0x30>                     <== NEVER TAKEN
40028168:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanInt(fp, &grgid)                                            
4002816c:	7f ff ff 64 	call  40027efc <scanInt>                       
40028170:	92 07 bf f8 	add  %fp, -8, %o1                              
40028174:	80 a2 20 00 	cmp  %o0, 0                                    
40028178:	02 bf ff f3 	be  40028144 <scangr+0x30>                     <== NEVER TAKEN
4002817c:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &grmem, &buffer, &bufsize, 1))                  
40028180:	92 07 bf fc 	add  %fp, -4, %o1                              
40028184:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40028188:	96 07 a0 50 	add  %fp, 0x50, %o3                            
4002818c:	7f ff ff a7 	call  40028028 <scanString>                    
40028190:	98 10 20 01 	mov  1, %o4                                    
40028194:	80 a2 20 00 	cmp  %o0, 0                                    
40028198:	02 bf ff eb 	be  40028144 <scangr+0x30>                     <== NEVER TAKEN
4002819c:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
400281a0:	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;                                                
400281a4:	c2 36 60 08 	sth  %g1, [ %i1 + 8 ]                          
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
400281a8:	c6 0f 40 00 	ldub  [ %i5 ], %g3                             
400281ac:	83 28 e0 18 	sll  %g3, 0x18, %g1                            
400281b0:	80 a0 60 00 	cmp  %g1, 0                                    
400281b4:	02 80 00 10 	be  400281f4 <scangr+0xe0>                     <== NEVER TAKEN
400281b8:	88 10 20 17 	mov  0x17, %g4                                 
400281bc:	84 10 00 1d 	mov  %i5, %g2                                  
400281c0:	88 10 20 01 	mov  1, %g4                                    
400281c4:	84 00 a0 01 	inc  %g2                                       
400281c8:	c6 08 80 00 	ldub  [ %g2 ], %g3                             
    if(*cp == ',')                                                    
400281cc:	83 38 60 18 	sra  %g1, 0x18, %g1                            
      memcount++;                                                     
400281d0:	82 18 60 2c 	xor  %g1, 0x2c, %g1                            
400281d4:	80 a0 00 01 	cmp  %g0, %g1                                  
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
400281d8:	83 28 e0 18 	sll  %g3, 0x18, %g1                            
    if(*cp == ',')                                                    
      memcount++;                                                     
400281dc:	88 61 3f ff 	subx  %g4, -1, %g4                             
  grp->gr_gid = grgid;                                                
                                                                      
  /*                                                                  
   * Determine number of members                                      
   */                                                                 
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
400281e0:	80 a0 60 00 	cmp  %g1, 0                                    
400281e4:	32 bf ff f9 	bne,a   400281c8 <scangr+0xb4>                 
400281e8:	84 00 a0 01 	inc  %g2                                       
400281ec:	89 29 20 02 	sll  %g4, 2, %g4                               
400281f0:	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))                 
400281f4:	c2 07 a0 50 	ld  [ %fp + 0x50 ], %g1                        
400281f8:	80 a0 40 04 	cmp  %g1, %g4                                  
400281fc:	0a bf ff d2 	bcs  40028144 <scangr+0x30>                    <== NEVER TAKEN
40028200:	c2 07 a0 4c 	ld  [ %fp + 0x4c ], %g1                        
    return 0;                                                         
  grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);            
40028204:	82 00 60 0f 	add  %g1, 0xf, %g1                             
40028208:	82 08 7f f0 	and  %g1, -16, %g1                             
4002820c:	c2 26 60 0c 	st  %g1, [ %i1 + 0xc ]                         
                                                                      
  /*                                                                  
   * Fill in pointer array                                            
   */                                                                 
  grp->gr_mem[0] = grmem;                                             
40028210:	fa 20 40 00 	st  %i5, [ %g1 ]                               
  for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {                  
40028214:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40028218:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
4002821c:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
40028220:	80 a0 a0 00 	cmp  %g2, 0                                    
40028224:	02 80 00 18 	be  40028284 <scangr+0x170>                    <== NEVER TAKEN
40028228:	82 00 60 01 	inc  %g1                                       
4002822c:	10 80 00 07 	b  40028248 <scangr+0x134>                     
40028230:	86 10 20 01 	mov  1, %g3                                    
40028234:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
40028238:	85 28 a0 18 	sll  %g2, 0x18, %g2                            
4002823c:	80 a0 a0 00 	cmp  %g2, 0                                    
40028240:	02 80 00 0c 	be  40028270 <scangr+0x15c>                    
40028244:	82 00 60 01 	inc  %g1                                       
    if(*cp == ',') {                                                  
40028248:	85 38 a0 18 	sra  %g2, 0x18, %g2                            
4002824c:	80 a0 a0 2c 	cmp  %g2, 0x2c                                 
40028250:	32 bf ff fa 	bne,a   40028238 <scangr+0x124>                
40028254:	c4 08 40 00 	ldub  [ %g1 ], %g2                             
      *cp = '\0';                                                     
40028258:	c0 28 7f ff 	clrb  [ %g1 + -1 ]                             
      grp->gr_mem[memcount++] = cp + 1;                               
4002825c:	c8 06 60 0c 	ld  [ %i1 + 0xc ], %g4                         
40028260:	85 28 e0 02 	sll  %g3, 2, %g2                               
40028264:	86 00 e0 01 	inc  %g3                                       
40028268:	10 bf ff f3 	b  40028234 <scangr+0x120>                     
4002826c:	c2 21 00 02 	st  %g1, [ %g4 + %g2 ]                         
40028270:	87 28 e0 02 	sll  %g3, 2, %g3                               
    }                                                                 
  }                                                                   
  grp->gr_mem[memcount] = NULL;                                       
40028274:	c2 06 60 0c 	ld  [ %i1 + 0xc ], %g1                         
40028278:	c0 20 40 03 	clr  [ %g1 + %g3 ]                             
  return 1;                                                           
}                                                                     
4002827c:	81 c7 e0 08 	ret                                            
40028280:	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++) {                  
40028284:	10 bf ff fc 	b  40028274 <scangr+0x160>                     <== NOT EXECUTED
40028288:	86 10 20 04 	mov  4, %g3                                    <== NOT EXECUTED
                                                                      

4002828c <scanpw>: FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) {
4002828c:	9d e3 bf 98 	save  %sp, -104, %sp                           
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
40028290:	98 10 20 00 	clr  %o4                                       
  FILE *fp,                                                           
  struct passwd *pwd,                                                 
  char *buffer,                                                       
  size_t bufsize                                                      
)                                                                     
{                                                                     
40028294:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
40028298:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
  int pwuid, pwgid;                                                   
                                                                      
  if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)            
4002829c:	90 10 00 18 	mov  %i0, %o0                                  
400282a0:	92 10 00 19 	mov  %i1, %o1                                  
400282a4:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
400282a8:	7f ff ff 60 	call  40028028 <scanString>                    
400282ac:	96 07 a0 50 	add  %fp, 0x50, %o3                            
400282b0:	80 a2 20 00 	cmp  %o0, 0                                    
400282b4:	12 80 00 04 	bne  400282c4 <scanpw+0x38>                    
400282b8:	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;                                                         
400282bc:	81 c7 e0 08 	ret                                            
400282c0:	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)          
400282c4:	92 06 60 04 	add  %i1, 4, %o1                               
400282c8:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
400282cc:	96 07 a0 50 	add  %fp, 0x50, %o3                            
400282d0:	7f ff ff 56 	call  40028028 <scanString>                    
400282d4:	98 10 20 00 	clr  %o4                                       
400282d8:	80 a2 20 00 	cmp  %o0, 0                                    
400282dc:	02 bf ff f8 	be  400282bc <scanpw+0x30>                     <== NEVER TAKEN
400282e0:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanInt(fp, &pwuid)                                            
400282e4:	7f ff ff 06 	call  40027efc <scanInt>                       
400282e8:	92 07 bf f8 	add  %fp, -8, %o1                              
400282ec:	80 a2 20 00 	cmp  %o0, 0                                    
400282f0:	02 bf ff f3 	be  400282bc <scanpw+0x30>                     
400282f4:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanInt(fp, &pwgid)                                            
400282f8:	7f ff ff 01 	call  40027efc <scanInt>                       
400282fc:	92 07 bf fc 	add  %fp, -4, %o1                              
40028300:	80 a2 20 00 	cmp  %o0, 0                                    
40028304:	02 bf ff ee 	be  400282bc <scanpw+0x30>                     
40028308:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)         
4002830c:	92 06 60 0c 	add  %i1, 0xc, %o1                             
40028310:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40028314:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40028318:	7f ff ff 44 	call  40028028 <scanString>                    
4002831c:	98 10 20 00 	clr  %o4                                       
40028320:	80 a2 20 00 	cmp  %o0, 0                                    
40028324:	02 bf ff e6 	be  400282bc <scanpw+0x30>                     <== NEVER TAKEN
40028328:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)           
4002832c:	92 06 60 10 	add  %i1, 0x10, %o1                            
40028330:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40028334:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40028338:	7f ff ff 3c 	call  40028028 <scanString>                    
4002833c:	98 10 20 00 	clr  %o4                                       
40028340:	80 a2 20 00 	cmp  %o0, 0                                    
40028344:	02 bf ff de 	be  400282bc <scanpw+0x30>                     <== NEVER TAKEN
40028348:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)             
4002834c:	92 06 60 14 	add  %i1, 0x14, %o1                            
40028350:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40028354:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40028358:	7f ff ff 34 	call  40028028 <scanString>                    
4002835c:	98 10 20 00 	clr  %o4                                       
40028360:	80 a2 20 00 	cmp  %o0, 0                                    
40028364:	02 bf ff d6 	be  400282bc <scanpw+0x30>                     <== NEVER TAKEN
40028368:	90 10 00 18 	mov  %i0, %o0                                  
   || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))          
4002836c:	92 06 60 18 	add  %i1, 0x18, %o1                            
40028370:	94 07 a0 4c 	add  %fp, 0x4c, %o2                            
40028374:	96 07 a0 50 	add  %fp, 0x50, %o3                            
40028378:	7f ff ff 2c 	call  40028028 <scanString>                    
4002837c:	98 10 20 01 	mov  1, %o4                                    
40028380:	80 a2 20 00 	cmp  %o0, 0                                    
40028384:	02 bf ff ce 	be  400282bc <scanpw+0x30>                     
40028388:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
    return 0;                                                         
  pwd->pw_uid = pwuid;                                                
4002838c:	c2 36 60 08 	sth  %g1, [ %i1 + 8 ]                          
  pwd->pw_gid = pwgid;                                                
40028390:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40028394:	c2 36 60 0a 	sth  %g1, [ %i1 + 0xa ]                        
  return 1;                                                           
}                                                                     
40028398:	81 c7 e0 08 	ret                                            
4002839c:	91 e8 20 01 	restore  %g0, 1, %o0                           
                                                                      

400089dc <sched_get_priority_max>: #include <rtems/posix/priority.h> int sched_get_priority_max( int policy ) {
400089dc:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch ( policy ) {                                                 
400089e0:	80 a6 20 04 	cmp  %i0, 4                                    
400089e4:	08 80 00 08 	bleu  40008a04 <sched_get_priority_max+0x28>   
400089e8:	82 10 20 01 	mov  1, %g1                                    
    case SCHED_RR:                                                    
    case SCHED_SPORADIC:                                              
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
400089ec:	40 00 22 40 	call  400112ec <__errno>                       
400089f0:	b0 10 3f ff 	mov  -1, %i0                                   
400089f4:	82 10 20 16 	mov  0x16, %g1                                 
400089f8:	c2 22 00 00 	st  %g1, [ %o0 ]                               
400089fc:	81 c7 e0 08 	ret                                            
40008a00:	81 e8 00 00 	restore                                        
                                                                      
int sched_get_priority_max(                                           
  int  policy                                                         
)                                                                     
{                                                                     
  switch ( policy ) {                                                 
40008a04:	b1 28 40 18 	sll  %g1, %i0, %i0                             
40008a08:	80 8e 20 17 	btst  0x17, %i0                                
40008a0c:	02 bf ff f8 	be  400089ec <sched_get_priority_max+0x10>     <== NEVER TAKEN
40008a10:	03 10 00 7f 	sethi  %hi(0x4001fc00), %g1                    
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  }                                                                   
                                                                      
  return POSIX_SCHEDULER_MAXIMUM_PRIORITY;                            
40008a14:	f0 08 63 fc 	ldub  [ %g1 + 0x3fc ], %i0	! 4001fffc <rtems_maximum_priority>
}                                                                     
40008a18:	81 c7 e0 08 	ret                                            
40008a1c:	91 ee 3f ff 	restore  %i0, -1, %o0                          
                                                                      

40008a20 <sched_get_priority_min>: * 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258 */ int sched_get_priority_min( int policy ) {
40008a20:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch ( policy ) {                                                 
40008a24:	80 a6 20 04 	cmp  %i0, 4                                    
40008a28:	08 80 00 08 	bleu  40008a48 <sched_get_priority_min+0x28>   
40008a2c:	82 10 00 18 	mov  %i0, %g1                                  
    case SCHED_RR:                                                    
    case SCHED_SPORADIC:                                              
      break;                                                          
                                                                      
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
40008a30:	40 00 22 2f 	call  400112ec <__errno>                       
40008a34:	b0 10 3f ff 	mov  -1, %i0                                   
40008a38:	82 10 20 16 	mov  0x16, %g1                                 
40008a3c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
  }                                                                   
                                                                      
  return POSIX_SCHEDULER_MINIMUM_PRIORITY;                            
}                                                                     
40008a40:	81 c7 e0 08 	ret                                            
40008a44:	81 e8 00 00 	restore                                        
 */                                                                   
int sched_get_priority_min(                                           
  int  policy                                                         
)                                                                     
{                                                                     
  switch ( policy ) {                                                 
40008a48:	84 10 20 01 	mov  1, %g2                                    
40008a4c:	83 28 80 01 	sll  %g2, %g1, %g1                             
40008a50:	80 88 60 17 	btst  0x17, %g1                                
40008a54:	02 bf ff f7 	be  40008a30 <sched_get_priority_min+0x10>     <== NEVER TAKEN
40008a58:	b0 10 20 01 	mov  1, %i0                                    
    default:                                                          
      rtems_set_errno_and_return_minus_one( EINVAL );                 
  }                                                                   
                                                                      
  return POSIX_SCHEDULER_MINIMUM_PRIORITY;                            
}                                                                     
40008a5c:	81 c7 e0 08 	ret                                            
40008a60:	81 e8 00 00 	restore                                        
                                                                      

40008a64 <sched_rr_get_interval>: int sched_rr_get_interval( pid_t pid, struct timespec *interval ) {
40008a64:	9d e3 bf a0 	save  %sp, -96, %sp                            
  /*                                                                  
   *  Only supported for the "calling process" (i.e. this node).      
   */                                                                 
                                                                      
  if ( pid && pid != getpid() )                                       
40008a68:	80 a6 20 00 	cmp  %i0, 0                                    
40008a6c:	12 80 00 0a 	bne  40008a94 <sched_rr_get_interval+0x30>     <== ALWAYS TAKEN
40008a70:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( ESRCH );                    
                                                                      
  if ( !interval )                                                    
40008a74:	02 80 00 13 	be  40008ac0 <sched_rr_get_interval+0x5c>      
40008a78:	03 10 00 83 	sethi  %hi(0x40020c00), %g1                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );      
40008a7c:	d0 00 61 00 	ld  [ %g1 + 0x100 ], %o0	! 40020d00 <_Thread_Ticks_per_timeslice>
40008a80:	92 10 00 19 	mov  %i1, %o1                                  
40008a84:	40 00 0f 59 	call  4000c7e8 <_Timespec_From_ticks>          
40008a88:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
40008a8c:	81 c7 e0 08 	ret                                            
40008a90:	81 e8 00 00 	restore                                        
{                                                                     
  /*                                                                  
   *  Only supported for the "calling process" (i.e. this node).      
   */                                                                 
                                                                      
  if ( pid && pid != getpid() )                                       
40008a94:	7f ff ee e5 	call  40004628 <getpid>                        
40008a98:	01 00 00 00 	nop                                            
40008a9c:	80 a2 00 18 	cmp  %o0, %i0                                  
40008aa0:	02 bf ff f5 	be  40008a74 <sched_rr_get_interval+0x10>      
40008aa4:	80 a6 60 00 	cmp  %i1, 0                                    
    rtems_set_errno_and_return_minus_one( ESRCH );                    
40008aa8:	40 00 22 11 	call  400112ec <__errno>                       
40008aac:	b0 10 3f ff 	mov  -1, %i0                                   
40008ab0:	82 10 20 03 	mov  3, %g1                                    
40008ab4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40008ab8:	81 c7 e0 08 	ret                                            
40008abc:	81 e8 00 00 	restore                                        
                                                                      
  if ( !interval )                                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
40008ac0:	40 00 22 0b 	call  400112ec <__errno>                       
40008ac4:	b0 10 3f ff 	mov  -1, %i0                                   
40008ac8:	82 10 20 16 	mov  0x16, %g1                                 
40008acc:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40008ad0:	81 c7 e0 08 	ret                                            
40008ad4:	81 e8 00 00 	restore                                        
                                                                      

4000932c <sem_open>: int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) {
4000932c:	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;                  
40009330:	03 10 00 93 	sethi  %hi(0x40024c00), %g1                    
40009334:	c4 00 60 b0 	ld  [ %g1 + 0xb0 ], %g2	! 40024cb0 <_Thread_Dispatch_disable_level>
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
40009338:	f4 27 a0 4c 	st  %i2, [ %fp + 0x4c ]                        
                                                                      
    ++level;                                                          
4000933c:	84 00 a0 01 	inc  %g2                                       
40009340:	f6 27 a0 50 	st  %i3, [ %fp + 0x50 ]                        
40009344:	f8 27 a0 54 	st  %i4, [ %fp + 0x54 ]                        
40009348:	fa 27 a0 58 	st  %i5, [ %fp + 0x58 ]                        
    _Thread_Dispatch_disable_level = level;                           
4000934c:	c4 20 60 b0 	st  %g2, [ %g1 + 0xb0 ]                        
  Objects_Locations          location;                                
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
40009350:	b4 8e 62 00 	andcc  %i1, 0x200, %i2                         
40009354:	12 80 00 27 	bne  400093f0 <sem_open+0xc4>                  
40009358:	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 );
4000935c:	39 10 00 93 	sethi  %hi(0x40024c00), %i4                    
40009360:	92 10 00 18 	mov  %i0, %o1                                  
40009364:	90 17 23 74 	or  %i4, 0x374, %o0                            
40009368:	94 07 bf f0 	add  %fp, -16, %o2                             
4000936c:	7f ff fe 5c 	call  40008cdc <_POSIX_Name_to_id>             
40009370:	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 ) {                                                     
40009374:	ba 92 20 00 	orcc  %o0, 0, %i5                              
40009378:	22 80 00 0e 	be,a   400093b0 <sem_open+0x84>                
4000937c:	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) ) ) {               
40009380:	80 a7 60 02 	cmp  %i5, 2                                    
40009384:	12 80 00 04 	bne  40009394 <sem_open+0x68>                  
40009388:	80 a6 a0 00 	cmp  %i2, 0                                    
4000938c:	12 80 00 1d 	bne  40009400 <sem_open+0xd4>                  
40009390:	d2 07 bf fc 	ld  [ %fp + -4 ], %o1                          
      _Thread_Enable_dispatch();                                      
40009394:	40 00 0e 73 	call  4000cd60 <_Thread_Enable_dispatch>       
40009398:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( status, sem_t * );   
4000939c:	40 00 25 30 	call  4001285c <__errno>                       
400093a0:	01 00 00 00 	nop                                            
400093a4:	fa 22 00 00 	st  %i5, [ %o0 ]                               
400093a8:	81 c7 e0 08 	ret                                            
400093ac:	81 e8 00 00 	restore                                        
                                                                      
    /*                                                                
     * Check for existence with creation.                             
     */                                                               
                                                                      
    if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {       
400093b0:	80 a6 6a 00 	cmp  %i1, 0xa00                                
400093b4:	02 80 00 1f 	be  40009430 <sem_open+0x104>                  
400093b8:	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 *)                                  
400093bc:	94 07 bf f8 	add  %fp, -8, %o2                              
400093c0:	40 00 0a 7a 	call  4000bda8 <_Objects_Get>                  
400093c4:	90 17 23 74 	or  %i4, 0x374, %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;                                   
400093c8:	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 );
400093cc:	d0 27 bf f4 	st  %o0, [ %fp + -12 ]                         
    the_semaphore->open_count += 1;                                   
400093d0:	82 00 60 01 	inc  %g1                                       
    _Thread_Enable_dispatch();                                        
400093d4:	40 00 0e 63 	call  4000cd60 <_Thread_Enable_dispatch>       
400093d8:	c2 22 20 18 	st  %g1, [ %o0 + 0x18 ]                        
    _Thread_Enable_dispatch();                                        
400093dc:	40 00 0e 61 	call  4000cd60 <_Thread_Enable_dispatch>       
400093e0:	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;                        
400093e4:	f0 07 bf f4 	ld  [ %fp + -12 ], %i0                         
400093e8:	81 c7 e0 08 	ret                                            
400093ec:	91 ee 20 08 	restore  %i0, 8, %o0                           
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
400093f0:	82 07 a0 4c 	add  %fp, 0x4c, %g1                            
    mode = va_arg( arg, mode_t );                                     
    value = va_arg( arg, unsigned int );                              
400093f4:	f6 07 a0 50 	ld  [ %fp + 0x50 ], %i3                        
  size_t                     name_len;                                
                                                                      
  _Thread_Disable_dispatch();                                         
                                                                      
  if ( oflag & O_CREAT ) {                                            
    va_start(arg, oflag);                                             
400093f8:	10 bf ff d9 	b  4000935c <sem_open+0x30>                    
400093fc:	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(                            
40009400:	94 10 20 00 	clr  %o2                                       
40009404:	96 10 00 1b 	mov  %i3, %o3                                  
40009408:	98 07 bf f4 	add  %fp, -12, %o4                             
4000940c:	40 00 1a e9 	call  4000ffb0 <_POSIX_Semaphore_Create_support>
40009410:	90 10 00 18 	mov  %i0, %o0                                  
                                                                      
  /*                                                                  
   * errno was set by Create_support, so don't set it again.          
   */                                                                 
                                                                      
  _Thread_Enable_dispatch();                                          
40009414:	40 00 0e 53 	call  4000cd60 <_Thread_Enable_dispatch>       
40009418:	ba 10 00 08 	mov  %o0, %i5                                  
                                                                      
  if ( status == -1 )                                                 
4000941c:	80 a7 7f ff 	cmp  %i5, -1                                   
40009420:	32 bf ff f2 	bne,a   400093e8 <sem_open+0xbc>               <== ALWAYS TAKEN
40009424:	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                                                              
}                                                                     
40009428:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000942c:	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();                                      
40009430:	40 00 0e 4c 	call  4000cd60 <_Thread_Enable_dispatch>       
40009434:	b0 10 3f ff 	mov  -1, %i0                                   
      rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );   
40009438:	40 00 25 09 	call  4001285c <__errno>                       
4000943c:	01 00 00 00 	nop                                            
40009440:	82 10 20 11 	mov  0x11, %g1	! 11 <PROM_START+0x11>          
40009444:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40009448:	81 c7 e0 08 	ret                                            
4000944c:	81 e8 00 00 	restore                                        
                                                                      

4000b484 <sem_timedwait>: int sem_timedwait( sem_t *sem, const struct timespec *abstime ) {
4000b484:	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 );       
4000b488:	90 10 00 19 	mov  %i1, %o0                                  
4000b48c:	40 00 16 9f 	call  40010f08 <_POSIX_Absolute_timeout_to_ticks>
4000b490:	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 ); 
4000b494:	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 )                
4000b498:	80 a2 20 03 	cmp  %o0, 3                                    
4000b49c:	02 80 00 06 	be  4000b4b4 <sem_timedwait+0x30>              <== ALWAYS TAKEN
4000b4a0:	90 10 00 18 	mov  %i0, %o0                                  
    do_wait = false;                                                  
                                                                      
  lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 
4000b4a4:	40 00 19 99 	call  40011b08 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED
4000b4a8:	92 10 20 00 	clr  %o1                                       <== NOT EXECUTED
4000b4ac:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000b4b0:	91 e8 00 08 	restore  %g0, %o0, %o0                         <== NOT EXECUTED
4000b4b4:	40 00 19 95 	call  40011b08 <_POSIX_Semaphore_Wait_support> 
4000b4b8:	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;                                                 
}                                                                     
4000b4bc:	81 c7 e0 08 	ret                                            
4000b4c0:	91 e8 00 08 	restore  %g0, %o0, %o0                         
                                                                      

40008990 <sigaction>: int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) {
40008990:	9d e3 bf a0 	save  %sp, -96, %sp                            
  ISR_Level     level;                                                
                                                                      
  if ( oact )                                                         
40008994:	80 a6 a0 00 	cmp  %i2, 0                                    
40008998:	02 80 00 0d 	be  400089cc <sigaction+0x3c>                  
4000899c:	87 2e 20 02 	sll  %i0, 2, %g3                               
    *oact = _POSIX_signals_Vectors[ sig ];                            
400089a0:	05 10 00 6f 	sethi  %hi(0x4001bc00), %g2                    
400089a4:	83 2e 20 04 	sll  %i0, 4, %g1                               
400089a8:	84 10 a1 60 	or  %g2, 0x160, %g2                            
400089ac:	82 20 40 03 	sub  %g1, %g3, %g1                             
400089b0:	c6 00 80 01 	ld  [ %g2 + %g1 ], %g3                         
400089b4:	82 00 80 01 	add  %g2, %g1, %g1                             
400089b8:	c6 26 80 00 	st  %g3, [ %i2 ]                               
400089bc:	c4 00 60 04 	ld  [ %g1 + 4 ], %g2                           
400089c0:	c4 26 a0 04 	st  %g2, [ %i2 + 4 ]                           
400089c4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
400089c8:	c2 26 a0 08 	st  %g1, [ %i2 + 8 ]                           
                                                                      
  if ( !sig )                                                         
400089cc:	80 a6 20 00 	cmp  %i0, 0                                    
400089d0:	02 80 00 33 	be  40008a9c <sigaction+0x10c>                 
400089d4:	01 00 00 00 	nop                                            
                                                                      
static inline bool is_valid_signo(                                    
  int signo                                                           
)                                                                     
{                                                                     
  return ((signo) >= 1 && (signo) <= 32 );                            
400089d8:	82 06 3f ff 	add  %i0, -1, %g1                              
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !is_valid_signo(sig) )                                         
400089dc:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
400089e0:	18 80 00 2f 	bgu  40008a9c <sigaction+0x10c>                
400089e4:	80 a6 20 09 	cmp  %i0, 9                                    
   *                                                                  
   *  NOTE: Solaris documentation claims to "silently enforce" this which
   *        contradicts the POSIX specification.                      
   */                                                                 
                                                                      
  if ( sig == SIGKILL )                                               
400089e8:	02 80 00 2d 	be  40008a9c <sigaction+0x10c>                 
400089ec:	80 a6 60 00 	cmp  %i1, 0                                    
  /*                                                                  
   *  Evaluate the new action structure and set the global signal vector
   *  appropriately.                                                  
   */                                                                 
                                                                      
  if ( act ) {                                                        
400089f0:	02 80 00 1a 	be  40008a58 <sigaction+0xc8>                  <== NEVER TAKEN
400089f4:	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 );                                            
400089f8:	7f ff e7 a2 	call  40002880 <sparc_disable_interrupts>      
400089fc:	01 00 00 00 	nop                                            
40008a00:	ba 10 00 08 	mov  %o0, %i5                                  
      if ( act->sa_handler == SIG_DFL ) {                             
40008a04:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
40008a08:	80 a0 60 00 	cmp  %g1, 0                                    
40008a0c:	02 80 00 15 	be  40008a60 <sigaction+0xd0>                  
40008a10:	83 2e 20 02 	sll  %i0, 2, %g1                               
        _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
      } else {                                                        
         _POSIX_signals_Clear_process_signals( sig );                 
40008a14:	40 00 17 f0 	call  4000e9d4 <_POSIX_signals_Clear_process_signals>
40008a18:	90 10 00 18 	mov  %i0, %o0                                  
         _POSIX_signals_Vectors[ sig ] = *act;                        
40008a1c:	c4 06 40 00 	ld  [ %i1 ], %g2                               
40008a20:	87 2e 20 02 	sll  %i0, 2, %g3                               
40008a24:	03 10 00 6f 	sethi  %hi(0x4001bc00), %g1                    
40008a28:	b1 2e 20 04 	sll  %i0, 4, %i0                               
40008a2c:	82 10 61 60 	or  %g1, 0x160, %g1                            
40008a30:	b0 26 00 03 	sub  %i0, %g3, %i0                             
40008a34:	c4 20 40 18 	st  %g2, [ %g1 + %i0 ]                         
40008a38:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
40008a3c:	b0 00 40 18 	add  %g1, %i0, %i0                             
40008a40:	c4 26 20 04 	st  %g2, [ %i0 + 4 ]                           
40008a44:	c2 06 60 08 	ld  [ %i1 + 8 ], %g1                           
40008a48:	c2 26 20 08 	st  %g1, [ %i0 + 8 ]                           
      }                                                               
    _ISR_Enable( level );                                             
40008a4c:	7f ff e7 91 	call  40002890 <sparc_enable_interrupts>       
40008a50:	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;                                                           
40008a54:	82 10 20 00 	clr  %g1                                       
}                                                                     
40008a58:	81 c7 e0 08 	ret                                            
40008a5c:	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 ];
40008a60:	b1 2e 20 04 	sll  %i0, 4, %i0                               
40008a64:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40008a68:	03 10 00 68 	sethi  %hi(0x4001a000), %g1                    
40008a6c:	82 10 62 5c 	or  %g1, 0x25c, %g1	! 4001a25c <_POSIX_signals_Default_vectors>
40008a70:	c8 00 40 18 	ld  [ %g1 + %i0 ], %g4                         
40008a74:	82 00 40 18 	add  %g1, %i0, %g1                             
40008a78:	c6 00 60 04 	ld  [ %g1 + 4 ], %g3                           
40008a7c:	c4 00 60 08 	ld  [ %g1 + 8 ], %g2                           
40008a80:	03 10 00 6f 	sethi  %hi(0x4001bc00), %g1                    
40008a84:	82 10 61 60 	or  %g1, 0x160, %g1	! 4001bd60 <_POSIX_signals_Vectors>
40008a88:	c8 20 40 18 	st  %g4, [ %g1 + %i0 ]                         
40008a8c:	b0 00 40 18 	add  %g1, %i0, %i0                             
40008a90:	c6 26 20 04 	st  %g3, [ %i0 + 4 ]                           
40008a94:	10 bf ff ee 	b  40008a4c <sigaction+0xbc>                   
40008a98:	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 );                   
40008a9c:	40 00 23 2a 	call  40011744 <__errno>                       
40008aa0:	01 00 00 00 	nop                                            
40008aa4:	84 10 20 16 	mov  0x16, %g2	! 16 <PROM_START+0x16>          
40008aa8:	82 10 3f ff 	mov  -1, %g1                                   
40008aac:	10 bf ff eb 	b  40008a58 <sigaction+0xc8>                   
40008ab0:	c4 22 00 00 	st  %g2, [ %o0 ]                               
                                                                      

40008f20 <sigtimedwait>: int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) {
40008f20:	9d e3 bf 90 	save  %sp, -112, %sp                           
  ISR_Level          level;                                           
                                                                      
  /*                                                                  
   *  Error check parameters before disabling interrupts.             
   */                                                                 
  if ( !set )                                                         
40008f24:	ba 96 20 00 	orcc  %i0, 0, %i5                              
40008f28:	02 80 00 83 	be  40009134 <sigtimedwait+0x214>              
40008f2c:	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 ) {                                                    
40008f30:	02 80 00 5b 	be  4000909c <sigtimedwait+0x17c>              
40008f34:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
    if ( !_Timespec_Is_valid( timeout ) )                             
40008f38:	40 00 0f 9d 	call  4000cdac <_Timespec_Is_valid>            
40008f3c:	90 10 00 1a 	mov  %i2, %o0                                  
40008f40:	80 8a 20 ff 	btst  0xff, %o0                                
40008f44:	02 80 00 7c 	be  40009134 <sigtimedwait+0x214>              
40008f48:	01 00 00 00 	nop                                            
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    interval = _Timespec_To_ticks( timeout );                         
40008f4c:	40 00 0f ab 	call  4000cdf8 <_Timespec_To_ticks>            
40008f50:	90 10 00 1a 	mov  %i2, %o0                                  
                                                                      
    if ( !interval )                                                  
40008f54:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40008f58:	02 80 00 77 	be  40009134 <sigtimedwait+0x214>              <== NEVER TAKEN
40008f5c:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
  /*                                                                  
   *  Initialize local variables.                                     
   */                                                                 
                                                                      
  the_info = ( info ) ? info : &signal_information;                   
40008f60:	02 80 00 52 	be  400090a8 <sigtimedwait+0x188>              <== NEVER TAKEN
40008f64:	35 10 00 71 	sethi  %hi(0x4001c400), %i2                    
                                                                      
  the_thread = _Thread_Executing;                                     
40008f68:	35 10 00 71 	sethi  %hi(0x4001c400), %i2                    
40008f6c:	b4 16 a1 60 	or  %i2, 0x160, %i2	! 4001c560 <_Per_CPU_Information>
40008f70:	f8 06 a0 10 	ld  [ %i2 + 0x10 ], %i4                        
   *  What if they are already pending?                               
   */                                                                 
                                                                      
  /* API signals pending? */                                          
                                                                      
  _ISR_Disable( level );                                              
40008f74:	7f ff e7 1e 	call  40002bec <sparc_disable_interrupts>      
40008f78:	f6 07 21 50 	ld  [ %i4 + 0x150 ], %i3                       
40008f7c:	a0 10 00 08 	mov  %o0, %l0                                  
  if ( *set & api->signals_pending ) {                                
40008f80:	c2 07 40 00 	ld  [ %i5 ], %g1                               
40008f84:	c4 06 e0 d4 	ld  [ %i3 + 0xd4 ], %g2                        
40008f88:	80 88 40 02 	btst  %g1, %g2                                 
40008f8c:	12 80 00 52 	bne  400090d4 <sigtimedwait+0x1b4>             
40008f90:	01 00 00 00 	nop                                            
    return the_info->si_signo;                                        
  }                                                                   
                                                                      
  /* Process pending signals? */                                      
                                                                      
  if ( *set & _POSIX_signals_Pending ) {                              
40008f94:	05 10 00 71 	sethi  %hi(0x4001c400), %g2                    
40008f98:	c4 00 a3 b4 	ld  [ %g2 + 0x3b4 ], %g2	! 4001c7b4 <_POSIX_signals_Pending>
40008f9c:	80 88 40 02 	btst  %g1, %g2                                 
40008fa0:	12 80 00 2e 	bne  40009058 <sigtimedwait+0x138>             
40008fa4:	03 10 00 70 	sethi  %hi(0x4001c000), %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;                  
40008fa8:	c4 00 60 50 	ld  [ %g1 + 0x50 ], %g2	! 4001c050 <_Thread_Dispatch_disable_level>
    the_info->si_code = SI_USER;                                      
    the_info->si_value.sival_int = 0;                                 
    return signo;                                                     
  }                                                                   
                                                                      
  the_info->si_signo = -1;                                            
40008fac:	86 10 3f ff 	mov  -1, %g3                                   
40008fb0:	c6 26 40 00 	st  %g3, [ %i1 ]                               
                                                                      
    ++level;                                                          
40008fb4:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
40008fb8:	c4 20 60 50 	st  %g2, [ %g1 + 0x50 ]                        
                                                                      
  _Thread_Disable_dispatch();                                         
    the_thread->Wait.queue           = &_POSIX_signals_Wait_queue;    
    the_thread->Wait.return_code     = EINTR;                         
40008fbc:	82 10 20 04 	mov  4, %g1                                    
40008fc0:	c2 27 20 34 	st  %g1, [ %i4 + 0x34 ]                        
    the_thread->Wait.option          = *set;                          
40008fc4:	c2 07 40 00 	ld  [ %i5 ], %g1                               
    the_thread->Wait.return_argument = the_info;                      
40008fc8:	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;                          
40008fcc:	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;
40008fd0:	a2 10 20 01 	mov  1, %l1                                    
  }                                                                   
                                                                      
  the_info->si_signo = -1;                                            
                                                                      
  _Thread_Disable_dispatch();                                         
    the_thread->Wait.queue           = &_POSIX_signals_Wait_queue;    
40008fd4:	21 10 00 71 	sethi  %hi(0x4001c400), %l0                    
40008fd8:	a0 14 23 4c 	or  %l0, 0x34c, %l0	! 4001c74c <_POSIX_signals_Wait_queue>
40008fdc:	e0 27 20 44 	st  %l0, [ %i4 + 0x44 ]                        
40008fe0:	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 );                                             
40008fe4:	7f ff e7 06 	call  40002bfc <sparc_enable_interrupts>       
40008fe8:	01 00 00 00 	nop                                            
    _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );    
40008fec:	90 10 00 10 	mov  %l0, %o0                                  
40008ff0:	92 10 00 18 	mov  %i0, %o1                                  
40008ff4:	15 10 00 32 	sethi  %hi(0x4000c800), %o2                    
40008ff8:	40 00 0d ff 	call  4000c7f4 <_Thread_queue_Enqueue_with_handler>
40008ffc:	94 12 a3 d4 	or  %o2, 0x3d4, %o2	! 4000cbd4 <_Thread_queue_Timeout>
  _Thread_Enable_dispatch();                                          
40009000:	40 00 0c bd 	call  4000c2f4 <_Thread_Enable_dispatch>       
40009004:	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 );
40009008:	d2 06 40 00 	ld  [ %i1 ], %o1                               
4000900c:	90 10 00 1b 	mov  %i3, %o0                                  
40009010:	94 10 00 19 	mov  %i1, %o2                                  
40009014:	96 10 20 00 	clr  %o3                                       
40009018:	40 00 18 ac 	call  4000f2c8 <_POSIX_signals_Clear_signals>  
4000901c:	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)                 
40009020:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
40009024:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
40009028:	80 a0 60 04 	cmp  %g1, 4                                    
4000902c:	12 80 00 3b 	bne  40009118 <sigtimedwait+0x1f8>             
40009030:	01 00 00 00 	nop                                            
       || !(*set & signo_to_mask( the_info->si_signo )) ) {           
40009034:	f0 06 40 00 	ld  [ %i1 ], %i0                               
40009038:	c2 07 40 00 	ld  [ %i5 ], %g1                               
4000903c:	84 06 3f ff 	add  %i0, -1, %g2                              
40009040:	a3 2c 40 02 	sll  %l1, %g2, %l1                             
40009044:	80 8c 40 01 	btst  %l1, %g1                                 
40009048:	02 80 00 34 	be  40009118 <sigtimedwait+0x1f8>              
4000904c:	01 00 00 00 	nop                                            
    errno = _Thread_Executing->Wait.return_code;                      
    return -1;                                                        
  }                                                                   
                                                                      
  return the_info->si_signo;                                          
}                                                                     
40009050:	81 c7 e0 08 	ret                                            
40009054:	81 e8 00 00 	restore                                        
  }                                                                   
                                                                      
  /* Process pending signals? */                                      
                                                                      
  if ( *set & _POSIX_signals_Pending ) {                              
    signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );      
40009058:	7f ff ff 9a 	call  40008ec0 <_POSIX_signals_Get_lowest>     
4000905c:	90 10 00 02 	mov  %g2, %o0                                  
    _POSIX_signals_Clear_signals( api, signo, the_info, true, false );
40009060:	94 10 00 19 	mov  %i1, %o2                                  
  }                                                                   
                                                                      
  /* Process pending signals? */                                      
                                                                      
  if ( *set & _POSIX_signals_Pending ) {                              
    signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );      
40009064:	b0 10 00 08 	mov  %o0, %i0                                  
    _POSIX_signals_Clear_signals( api, signo, the_info, true, false );
40009068:	96 10 20 01 	mov  1, %o3                                    
4000906c:	90 10 00 1b 	mov  %i3, %o0                                  
40009070:	92 10 00 18 	mov  %i0, %o1                                  
40009074:	40 00 18 95 	call  4000f2c8 <_POSIX_signals_Clear_signals>  
40009078:	98 10 20 00 	clr  %o4                                       
    _ISR_Enable( level );                                             
4000907c:	7f ff e6 e0 	call  40002bfc <sparc_enable_interrupts>       
40009080:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
    the_info->si_signo = signo;                                       
    the_info->si_code = SI_USER;                                      
40009084:	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;                                       
40009088:	f0 26 40 00 	st  %i0, [ %i1 ]                               
    the_info->si_code = SI_USER;                                      
4000908c:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]                           
    the_info->si_value.sival_int = 0;                                 
40009090:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
40009094:	81 c7 e0 08 	ret                                            
40009098:	81 e8 00 00 	restore                                        
                                                                      
  /*                                                                  
   *  Initialize local variables.                                     
   */                                                                 
                                                                      
  the_info = ( info ) ? info : &signal_information;                   
4000909c:	12 bf ff b3 	bne  40008f68 <sigtimedwait+0x48>              
400090a0:	b0 10 20 00 	clr  %i0                                       
                                                                      
  the_thread = _Thread_Executing;                                     
400090a4:	35 10 00 71 	sethi  %hi(0x4001c400), %i2                    
400090a8:	b4 16 a1 60 	or  %i2, 0x160, %i2	! 4001c560 <_Per_CPU_Information>
400090ac:	f8 06 a0 10 	ld  [ %i2 + 0x10 ], %i4                        
                                                                      
  /*                                                                  
   *  Initialize local variables.                                     
   */                                                                 
                                                                      
  the_info = ( info ) ? info : &signal_information;                   
400090b0:	b2 07 bf f4 	add  %fp, -12, %i1                             
   *  What if they are already pending?                               
   */                                                                 
                                                                      
  /* API signals pending? */                                          
                                                                      
  _ISR_Disable( level );                                              
400090b4:	7f ff e6 ce 	call  40002bec <sparc_disable_interrupts>      
400090b8:	f6 07 21 50 	ld  [ %i4 + 0x150 ], %i3                       
400090bc:	a0 10 00 08 	mov  %o0, %l0                                  
  if ( *set & api->signals_pending ) {                                
400090c0:	c2 07 40 00 	ld  [ %i5 ], %g1                               
400090c4:	c4 06 e0 d4 	ld  [ %i3 + 0xd4 ], %g2                        
400090c8:	80 88 40 02 	btst  %g1, %g2                                 
400090cc:	22 bf ff b3 	be,a   40008f98 <sigtimedwait+0x78>            
400090d0:	05 10 00 71 	sethi  %hi(0x4001c400), %g2                    
    /* XXX real info later */                                         
    the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
400090d4:	7f ff ff 7b 	call  40008ec0 <_POSIX_signals_Get_lowest>     
400090d8:	90 10 00 02 	mov  %g2, %o0                                  
    _POSIX_signals_Clear_signals(                                     
400090dc:	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 );
400090e0:	92 10 00 08 	mov  %o0, %o1                                  
400090e4:	d0 26 40 00 	st  %o0, [ %i1 ]                               
    _POSIX_signals_Clear_signals(                                     
400090e8:	96 10 20 00 	clr  %o3                                       
400090ec:	90 10 00 1b 	mov  %i3, %o0                                  
400090f0:	40 00 18 76 	call  4000f2c8 <_POSIX_signals_Clear_signals>  
400090f4:	98 10 20 00 	clr  %o4                                       
      the_info->si_signo,                                             
      the_info,                                                       
      false,                                                          
      false                                                           
    );                                                                
    _ISR_Enable( level );                                             
400090f8:	7f ff e6 c1 	call  40002bfc <sparc_enable_interrupts>       
400090fc:	90 10 00 10 	mov  %l0, %o0                                  
                                                                      
    the_info->si_code = SI_USER;                                      
40009100:	82 10 20 01 	mov  1, %g1                                    
    the_info->si_value.sival_int = 0;                                 
40009104:	c0 26 60 08 	clr  [ %i1 + 8 ]                               
      false,                                                          
      false                                                           
    );                                                                
    _ISR_Enable( level );                                             
                                                                      
    the_info->si_code = SI_USER;                                      
40009108:	c2 26 60 04 	st  %g1, [ %i1 + 4 ]                           
    the_info->si_value.sival_int = 0;                                 
    return the_info->si_signo;                                        
4000910c:	f0 06 40 00 	ld  [ %i1 ], %i0                               
40009110:	81 c7 e0 08 	ret                                            
40009114:	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;                      
40009118:	40 00 23 6d 	call  40011ecc <__errno>                       
4000911c:	b0 10 3f ff 	mov  -1, %i0                                   
40009120:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
40009124:	c2 00 60 34 	ld  [ %g1 + 0x34 ], %g1                        
40009128:	c2 22 00 00 	st  %g1, [ %o0 ]                               
    return -1;                                                        
  }                                                                   
                                                                      
  return the_info->si_signo;                                          
}                                                                     
4000912c:	81 c7 e0 08 	ret                                            
40009130:	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 );                 
40009134:	40 00 23 66 	call  40011ecc <__errno>                       
40009138:	b0 10 3f ff 	mov  -1, %i0                                   
4000913c:	82 10 20 16 	mov  0x16, %g1                                 
40009140:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40009144:	81 c7 e0 08 	ret                                            
40009148:	81 e8 00 00 	restore                                        
                                                                      

4000ad4c <sigwait>: int sigwait( const sigset_t *set, int *sig ) {
4000ad4c:	9d e3 bf a0 	save  %sp, -96, %sp                            
  int status;                                                         
                                                                      
  status = sigtimedwait( set, NULL, NULL );                           
4000ad50:	92 10 20 00 	clr  %o1                                       
4000ad54:	90 10 00 18 	mov  %i0, %o0                                  
4000ad58:	7f ff ff 6e 	call  4000ab10 <sigtimedwait>                  
4000ad5c:	94 10 20 00 	clr  %o2                                       
                                                                      
  if ( status != -1 ) {                                               
4000ad60:	80 a2 3f ff 	cmp  %o0, -1                                   
4000ad64:	02 80 00 07 	be  4000ad80 <sigwait+0x34>                    
4000ad68:	80 a6 60 00 	cmp  %i1, 0                                    
    if ( sig )                                                        
4000ad6c:	02 80 00 0a 	be  4000ad94 <sigwait+0x48>                    <== NEVER TAKEN
4000ad70:	01 00 00 00 	nop                                            
      *sig = status;                                                  
4000ad74:	d0 26 40 00 	st  %o0, [ %i1 ]                               
    return 0;                                                         
4000ad78:	81 c7 e0 08 	ret                                            
4000ad7c:	91 e8 20 00 	restore  %g0, 0, %o0                           
  }                                                                   
                                                                      
  return errno;                                                       
4000ad80:	40 00 22 86 	call  40013798 <__errno>                       
4000ad84:	01 00 00 00 	nop                                            
4000ad88:	f0 02 00 00 	ld  [ %o0 ], %i0                               
4000ad8c:	81 c7 e0 08 	ret                                            
4000ad90:	81 e8 00 00 	restore                                        
}                                                                     
4000ad94:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ad98:	91 e8 20 00 	restore  %g0, 0, %o0                           <== NOT EXECUTED
                                                                      

400070a0 <siproc>: /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) {
400070a0:	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)) {
400070a4:	c2 06 60 3c 	ld  [ %i1 + 0x3c ], %g1                        
400070a8:	80 88 6e 78 	btst  0xe78, %g1                               
400070ac:	32 80 00 04 	bne,a   400070bc <siproc+0x1c>                 <== ALWAYS TAKEN
400070b0:	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);                                               
400070b4:	7f ff ff 64 	call  40006e44 <iproc>                         <== NOT EXECUTED
400070b8:	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); 
400070bc:	94 10 20 00 	clr  %o2                                       
400070c0:	40 00 05 33 	call  4000858c <rtems_semaphore_obtain>        
400070c4:	92 10 20 00 	clr  %o1                                       
    i = iproc (c, tty);                                               
400070c8:	90 10 00 18 	mov  %i0, %o0                                  
400070cc:	7f ff ff 5e 	call  40006e44 <iproc>                         
400070d0:	92 10 00 19 	mov  %i1, %o1                                  
400070d4:	b0 10 00 08 	mov  %o0, %i0                                  
    rtems_semaphore_release (tty->osem);                              
400070d8:	40 00 05 7c 	call  400086c8 <rtems_semaphore_release>       
400070dc:	d0 06 60 18 	ld  [ %i1 + 0x18 ], %o0                        
400070e0:	81 c7 e0 08 	ret                                            
400070e4:	81 e8 00 00 	restore                                        
                                                                      

4000fd40 <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 ) {
4000fd40:	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 ) {                                 
4000fd44:	03 30 06 10 	sethi  %hi(0xc0184000), %g1                    
4000fd48:	82 10 62 01 	or  %g1, 0x201, %g1	! c0184201 <LEON_REG+0x40184201>
4000fd4c:	80 a6 40 01 	cmp  %i1, %g1                                  
4000fd50:	02 80 00 23 	be  4000fddc <sparse_disk_ioctl+0x9c>          
4000fd54:	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 ) {                          
4000fd58:	03 08 00 10 	sethi  %hi(0x20004000), %g1                    
4000fd5c:	82 10 62 07 	or  %g1, 0x207, %g1	! 20004207 <RAM_SIZE+0x1fc04207>
4000fd60:	80 a6 40 01 	cmp  %i1, %g1                                  
4000fd64:	02 80 00 07 	be  4000fd80 <sparse_disk_ioctl+0x40>          
4000fd68:	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 );                       
4000fd6c:	92 10 00 19 	mov  %i1, %o1                                  
4000fd70:	40 00 0c ab 	call  4001301c <rtems_blkdev_ioctl>            
4000fd74:	94 10 00 1a 	mov  %i2, %o2                                  
4000fd78:	81 c7 e0 08 	ret                                            
4000fd7c:	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 );                         
4000fd80:	7f ff e9 e7 	call  4000a51c <rtems_semaphore_delete>        
4000fd84:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
                                                                      
    if ( RTEMS_SUCCESSFUL != sc )                                     
4000fd88:	80 a2 20 00 	cmp  %o0, 0                                    
4000fd8c:	12 80 00 a0 	bne  4001000c <sparse_disk_ioctl+0x2cc>        <== NEVER TAKEN
4000fd90:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
      rtems_fatal_error_occurred( 0xdeadbeef );                       
                                                                      
    sd->mutex = RTEMS_ID_NONE;                                        
                                                                      
    if ( NULL != sd->delete_handler )                                 
4000fd94:	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;                                        
4000fd98:	c0 26 c0 00 	clr  [ %i3 ]                                   
                                                                      
    if ( NULL != sd->delete_handler )                                 
4000fd9c:	80 a0 60 00 	cmp  %g1, 0                                    
4000fda0:	02 80 00 04 	be  4000fdb0 <sparse_disk_ioctl+0x70>          <== NEVER TAKEN
4000fda4:	b0 10 20 00 	clr  %i0                                       
      ( *sd->delete_handler )( sd );                                  
4000fda8:	9f c0 40 00 	call  %g1                                      
4000fdac:	90 10 00 1b 	mov  %i3, %o0                                  
4000fdb0:	81 c7 e0 08 	ret                                            
4000fdb4:	81 e8 00 00 	restore                                        
      bytes_handled += rv;                                            
      buff_size     -= rv;                                            
    }                                                                 
  }                                                                   
                                                                      
  rtems_semaphore_release( sparse_disk->mutex );                      
4000fdb8:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
4000fdbc:	7f ff ea 5e 	call  4000a734 <rtems_semaphore_release>       
4000fdc0:	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);                                          
4000fdc4:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           
4000fdc8:	90 10 00 1a 	mov  %i2, %o0                                  
4000fdcc:	9f c0 40 00 	call  %g1                                      
4000fdd0:	92 10 20 00 	clr  %o1                                       
    return rtems_blkdev_ioctl( dd, req, argp );                       
  }                                                                   
                                                                      
  errno = EINVAL;                                                     
  return -1;                                                          
}                                                                     
4000fdd4:	81 c7 e0 08 	ret                                            
4000fdd8:	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 ) {                                               
4000fddc:	e6 06 80 00 	ld  [ %i2 ], %l3                               
4000fde0:	80 a4 e0 01 	cmp  %l3, 1                                    
4000fde4:	18 80 00 84 	bgu  4000fff4 <sparse_disk_ioctl+0x2b4>        <== NEVER TAKEN
4000fde8:	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 );
4000fdec:	d0 06 c0 00 	ld  [ %i3 ], %o0                               
4000fdf0:	7f ff ea 02 	call  4000a5f8 <rtems_semaphore_obtain>        
4000fdf4:	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(                                                      
4000fdf8:	25 10 00 3f 	sethi  %hi(0x4000fc00), %l2                    
  size_t                  buff_size;                                  
  unsigned int            bytes_handled;                              
                                                                      
  rtems_semaphore_obtain( sparse_disk->mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
                                                                      
  for ( req_buffer = 0;                                               
4000fdfc:	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;                                     
4000fe00:	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(                                                      
4000fe04:	a4 14 a1 18 	or  %l2, 0x118, %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 );                  
4000fe08:	c2 06 a0 10 	ld  [ %i2 + 0x10 ], %g1                        
4000fe0c:	80 a0 40 14 	cmp  %g1, %l4                                  
4000fe10:	08 bf ff ea 	bleu  4000fdb8 <sparse_disk_ioctl+0x78>        
4000fe14:	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 ) ) {                      
4000fe18:	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];                          
4000fe1c:	86 00 e0 18 	add  %g3, 0x18, %g3                            
4000fe20:	82 06 80 03 	add  %i2, %g3, %g1                             
                                                                      
    bytes_handled  = 0;                                               
    buff           = (uint8_t *) scatter_gather->buffer;              
    block          = scatter_gather->block;                           
4000fe24:	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;              
4000fe28:	e2 00 60 08 	ld  [ %g1 + 8 ], %l1                           
    block          = scatter_gather->block;                           
    buff_size      = scatter_gather->length;                          
                                                                      
    while ( ( 0 <= rv ) && ( 0 < buff_size ) ) {                      
4000fe2c:	06 80 00 40 	bl  4000ff2c <sparse_disk_ioctl+0x1ec>         <== NEVER TAKEN
4000fe30:	f8 00 60 04 	ld  [ %g1 + 4 ], %i4                           
4000fe34:	80 a7 20 00 	cmp  %i4, 0                                    
4000fe38:	02 80 00 3d 	be  4000ff2c <sparse_disk_ioctl+0x1ec>         <== NEVER TAKEN
4000fe3c:	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 = {                                
4000fe40:	10 80 00 1d 	b  4000feb4 <sparse_disk_ioctl+0x174>          
4000fe44:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
4000fe48:	80 a7 00 01 	cmp  %i4, %g1                                  
4000fe4c:	38 80 00 02 	bgu,a   4000fe54 <sparse_disk_ioctl+0x114>     
4000fe50:	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(                                                      
4000fe54:	d2 06 e0 18 	ld  [ %i3 + 0x18 ], %o1                        
4000fe58:	d4 06 e0 08 	ld  [ %i3 + 8 ], %o2                           
4000fe5c:	90 07 bf f8 	add  %fp, -8, %o0                              
4000fe60:	96 10 20 08 	mov  8, %o3                                    
4000fe64:	40 00 35 a9 	call  4001d508 <bsearch>                       
4000fe68:	98 10 00 12 	mov  %l2, %o4                                  
    sparse_disk->used_count,                                          
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL != key )                                                  
4000fe6c:	80 a2 20 00 	cmp  %o0, 0                                    
4000fe70:	02 80 00 29 	be  4000ff14 <sparse_disk_ioctl+0x1d4>         
4000fe74:	94 10 00 1d 	mov  %i5, %o2                                  
    memcpy( buffer, key->data, bytes_to_copy );                       
4000fe78:	d2 02 20 04 	ld  [ %o0 + 4 ], %o1                           
4000fe7c:	40 00 38 6a 	call  4001e024 <memcpy>                        
4000fe80:	90 10 00 10 	mov  %l0, %o0                                  
4000fe84:	b8 27 00 1d 	sub  %i4, %i5, %i4                             
4000fe88:	82 38 00 1d 	xnor  %g0, %i5, %g1                            
4000fe8c:	80 a0 00 1c 	cmp  %g0, %i4                                  
4000fe90:	83 30 60 1f 	srl  %g1, 0x1f, %g1                            
4000fe94:	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;                                               
4000fe98:	84 10 00 1d 	mov  %i5, %g2                                  
4000fe9c:	82 08 c0 01 	and  %g3, %g1, %g1                             
        rv = sparse_disk_write_block( sparse_disk,                    
                                      block,                          
                                      &buff[bytes_handled],           
                                      buff_size );                    
                                                                      
      ++block;                                                        
4000fea0:	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 ) ) {                      
4000fea4:	80 88 60 ff 	btst  0xff, %g1                                
4000fea8:	02 80 00 21 	be  4000ff2c <sparse_disk_ioctl+0x1ec>         
4000feac:	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 = {                                
4000feb0:	f2 27 bf f8 	st  %i1, [ %fp + -8 ]                          
    .block = block,                                                   
    .data  = NULL                                                     
  };                                                                  
  size_t                 bytes_to_copy = sparse_disk->media_block_size;
4000feb4:	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 = {                                
4000feb8:	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,                     
4000febc:	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 )                                                     
4000fec0:	80 a4 e0 00 	cmp  %l3, 0                                    
4000fec4:	02 bf ff e1 	be  4000fe48 <sparse_disk_ioctl+0x108>         
4000fec8:	ba 10 00 1c 	mov  %i4, %i5                                  
4000fecc:	80 a7 00 01 	cmp  %i4, %g1                                  
4000fed0:	38 80 00 02 	bgu,a   4000fed8 <sparse_disk_ioctl+0x198>     
4000fed4:	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(                                                      
4000fed8:	d2 06 e0 18 	ld  [ %i3 + 0x18 ], %o1                        
4000fedc:	d4 06 e0 08 	ld  [ %i3 + 8 ], %o2                           
4000fee0:	90 07 bf f8 	add  %fp, -8, %o0                              
4000fee4:	96 10 20 08 	mov  8, %o3                                    
4000fee8:	40 00 35 88 	call  4001d508 <bsearch>                       
4000feec:	98 10 00 12 	mov  %l2, %o4                                  
    sparse_disk->used_count,                                          
    sizeof( rtems_sparse_disk_key ),                                  
    sparse_disk_compare                                               
    );                                                                
                                                                      
  if ( NULL == key ) {                                                
4000fef0:	aa 92 20 00 	orcc  %o0, 0, %l5                              
4000fef4:	02 80 00 1a 	be  4000ff5c <sparse_disk_ioctl+0x21c>         
4000fef8:	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 );                       
4000fefc:	d0 05 60 04 	ld  [ %l5 + 4 ], %o0                           
4000ff00:	92 10 00 10 	mov  %l0, %o1                                  
4000ff04:	40 00 38 48 	call  4001e024 <memcpy>                        
4000ff08:	94 10 00 1d 	mov  %i5, %o2                                  
4000ff0c:	10 bf ff df 	b  4000fe88 <sparse_disk_ioctl+0x148>          
4000ff10:	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 );         
4000ff14:	d2 0e e0 14 	ldub  [ %i3 + 0x14 ], %o1                      
4000ff18:	90 10 00 10 	mov  %l0, %o0                                  
4000ff1c:	40 00 38 7f 	call  4001e118 <memset>                        
4000ff20:	94 10 00 1c 	mov  %i4, %o2                                  
4000ff24:	10 bf ff d9 	b  4000fe88 <sparse_disk_ioctl+0x148>          
4000ff28:	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;                                               
4000ff2c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ff30:	16 bf ff b6 	bge  4000fe08 <sparse_disk_ioctl+0xc8>         <== ALWAYS TAKEN
4000ff34:	a8 05 20 01 	inc  %l4                                       
      bytes_handled += rv;                                            
      buff_size     -= rv;                                            
    }                                                                 
  }                                                                   
                                                                      
  rtems_semaphore_release( sparse_disk->mutex );                      
4000ff38:	d0 06 c0 00 	ld  [ %i3 ], %o0                               <== NOT EXECUTED
4000ff3c:	7f ff e9 fe 	call  4000a734 <rtems_semaphore_release>       <== NOT EXECUTED
4000ff40:	b0 10 20 00 	clr  %i0                                       <== NOT EXECUTED
4000ff44:	c2 06 a0 04 	ld  [ %i2 + 4 ], %g1                           <== NOT EXECUTED
4000ff48:	90 10 00 1a 	mov  %i2, %o0                                  <== NOT EXECUTED
4000ff4c:	9f c0 40 00 	call  %g1                                      <== NOT EXECUTED
4000ff50:	92 10 20 1b 	mov  0x1b, %o1                                 <== NOT EXECUTED
4000ff54:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4000ff58:	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 ) {
4000ff5c:	02 bf ff ca 	be  4000fe84 <sparse_disk_ioctl+0x144>         <== NEVER TAKEN
4000ff60:	82 10 20 00 	clr  %g1                                       
4000ff64:	10 80 00 05 	b  4000ff78 <sparse_disk_ioctl+0x238>          
4000ff68:	c8 0e e0 14 	ldub  [ %i3 + 0x14 ], %g4                      
4000ff6c:	80 a0 40 1d 	cmp  %g1, %i5                                  
4000ff70:	1a 80 00 0b 	bcc  4000ff9c <sparse_disk_ioctl+0x25c>        
4000ff74:	80 88 e0 ff 	btst  0xff, %g3                                
      if ( buffer[i] != sparse_disk->fill_pattern )                   
4000ff78:	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 ) {
4000ff7c:	82 00 60 01 	inc  %g1                                       
      if ( buffer[i] != sparse_disk->fill_pattern )                   
4000ff80:	84 18 80 04 	xor  %g2, %g4, %g2                             
4000ff84:	80 a0 00 02 	cmp  %g0, %g2                                  
4000ff88:	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 ) {
4000ff8c:	80 a0 a0 00 	cmp  %g2, 0                                    
4000ff90:	02 bf ff f7 	be  4000ff6c <sparse_disk_ioctl+0x22c>         
4000ff94:	86 10 00 02 	mov  %g2, %g3                                  
      if ( buffer[i] != sparse_disk->fill_pattern )                   
        block_needs_writing = true;                                   
    }                                                                 
                                                                      
    if ( block_needs_writing ) {                                      
4000ff98:	80 88 e0 ff 	btst  0xff, %g3                                
4000ff9c:	22 bf ff bb 	be,a   4000fe88 <sparse_disk_ioctl+0x148>      
4000ffa0:	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 ) {  
4000ffa4:	c2 06 e0 08 	ld  [ %i3 + 8 ], %g1                           
4000ffa8:	c4 06 e0 04 	ld  [ %i3 + 4 ], %g2                           
4000ffac:	80 a0 40 02 	cmp  %g1, %g2                                  
4000ffb0:	1a 80 00 0c 	bcc  4000ffe0 <sparse_disk_ioctl+0x2a0>        <== NEVER TAKEN
4000ffb4:	ab 28 60 03 	sll  %g1, 3, %l5                               
    key        = &sparse_disk->key_table[sparse_disk->used_count];    
4000ffb8:	d0 06 e0 18 	ld  [ %i3 + 0x18 ], %o0                        
    key->block = block;                                               
4000ffbc:	f2 22 00 15 	st  %i1, [ %o0 + %l5 ]                         
    ++sparse_disk->used_count;                                        
4000ffc0:	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];    
4000ffc4:	aa 02 00 15 	add  %o0, %l5, %l5                             
    key->block = block;                                               
    ++sparse_disk->used_count;                                        
4000ffc8:	d2 26 e0 08 	st  %o1, [ %i3 + 8 ]                           
    qsort( sparse_disk->key_table, sparse_disk->used_count,           
4000ffcc:	94 10 20 08 	mov  8, %o2                                    
4000ffd0:	40 00 38 98 	call  4001e230 <qsort>                         
4000ffd4:	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 );                       
4000ffd8:	10 bf ff ca 	b  4000ff00 <sparse_disk_ioctl+0x1c0>          
4000ffdc:	d0 05 60 04 	ld  [ %l5 + 4 ], %o0                           
4000ffe0:	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 ) {  
4000ffe4:	82 10 20 00 	clr  %g1                                       <== NOT EXECUTED
4000ffe8:	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;                                                        
4000ffec:	10 bf ff ad 	b  4000fea0 <sparse_disk_ioctl+0x160>          <== NOT EXECUTED
4000fff0:	84 10 3f ff 	mov  -1, %g2                                   <== NOT EXECUTED
    return 0;                                                         
  } else {                                                            
    return rtems_blkdev_ioctl( dd, req, argp );                       
  }                                                                   
                                                                      
  errno = EINVAL;                                                     
4000fff4:	40 00 35 67 	call  4001d590 <__errno>                       <== NOT EXECUTED
4000fff8:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4000fffc:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
40010000:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
  return -1;                                                          
40010004:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40010008:	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 );                       
4001000c:	7f ff eb 5c 	call  4000ad7c <rtems_fatal_error_occurred>    <== NOT EXECUTED
40010010:	90 12 22 ef 	or  %o0, 0x2ef, %o0                            <== NOT EXECUTED
                                                                      

40006754 <sync_per_thread>: fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) {
40006754:	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;                                        
40006758:	c2 06 21 48 	ld  [ %i0 + 0x148 ], %g1                       
   if ( this_reent ) {                                                
4000675c:	80 a0 60 00 	cmp  %g1, 0                                    
40006760:	02 80 00 0c 	be  40006790 <sync_per_thread+0x3c>            <== NEVER TAKEN
40006764:	3b 10 00 67 	sethi  %hi(0x40019c00), %i5                    
     current_reent = _Thread_Executing->libc_reent;                   
40006768:	ba 17 61 d0 	or  %i5, 0x1d0, %i5	! 40019dd0 <_Per_CPU_Information>
4000676c:	c4 07 60 10 	ld  [ %i5 + 0x10 ], %g2                        
     _Thread_Executing->libc_reent = this_reent;                      
     _fwalk (t->libc_reent, sync_wrapper);                            
40006770:	13 10 00 19 	sethi  %hi(0x40006400), %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;                   
40006774:	f8 00 a1 48 	ld  [ %g2 + 0x148 ], %i4                       
     _Thread_Executing->libc_reent = this_reent;                      
40006778:	c2 20 a1 48 	st  %g1, [ %g2 + 0x148 ]                       
     _fwalk (t->libc_reent, sync_wrapper);                            
4000677c:	d0 06 21 48 	ld  [ %i0 + 0x148 ], %o0                       
40006780:	40 00 2e f3 	call  4001234c <_fwalk>                        
40006784:	92 12 63 98 	or  %o1, 0x398, %o1                            
     _Thread_Executing->libc_reent = current_reent;                   
40006788:	c2 07 60 10 	ld  [ %i5 + 0x10 ], %g1                        
4000678c:	f8 20 61 48 	st  %i4, [ %g1 + 0x148 ]                       
40006790:	81 c7 e0 08 	ret                                            
40006794:	81 e8 00 00 	restore                                        
                                                                      

40007bc8 <sysconf>: */ long sysconf( int name ) {
40007bc8:	9d e3 bf a0 	save  %sp, -96, %sp                            
  if ( name == _SC_CLK_TCK )                                          
40007bcc:	80 a6 20 02 	cmp  %i0, 2                                    
40007bd0:	02 80 00 12 	be  40007c18 <sysconf+0x50>                    
40007bd4:	82 10 00 18 	mov  %i0, %g1                                  
    return (TOD_MICROSECONDS_PER_SECOND /                             
      rtems_configuration_get_microseconds_per_tick());               
                                                                      
  if ( name == _SC_OPEN_MAX )                                         
40007bd8:	80 a6 20 04 	cmp  %i0, 4                                    
40007bdc:	02 80 00 16 	be  40007c34 <sysconf+0x6c>                    
40007be0:	80 a0 60 33 	cmp  %g1, 0x33                                 
    return rtems_libio_number_iops;                                   
                                                                      
  if ( name == _SC_GETPW_R_SIZE_MAX )                                 
40007be4:	02 80 00 0b 	be  40007c10 <sysconf+0x48>                    
40007be8:	b0 10 24 00 	mov  0x400, %i0                                
    return 1024;                                                      
                                                                      
  if ( name == _SC_PAGESIZE )                                         
40007bec:	80 a0 60 08 	cmp  %g1, 8                                    
40007bf0:	02 80 00 08 	be  40007c10 <sysconf+0x48>                    
40007bf4:	31 00 00 04 	sethi  %hi(0x1000), %i0                        
    return PAGE_SIZE;                                                 
                                                                      
  if ( name == _SC_SYMLOOP_MAX )                                      
40007bf8:	80 a0 60 4f 	cmp  %g1, 0x4f                                 
40007bfc:	02 80 00 05 	be  40007c10 <sysconf+0x48>                    <== NEVER TAKEN
40007c00:	b0 10 20 20 	mov  0x20, %i0                                 
    return RTEMS_FILESYSTEM_SYMLOOP_MAX;                              
                                                                      
#if defined(__sparc__)                                                
  if ( name == 515 ) /* Solaris _SC_STACK_PROT */                     
40007c04:	80 a0 62 03 	cmp  %g1, 0x203                                
40007c08:	12 80 00 0f 	bne  40007c44 <sysconf+0x7c>                   <== ALWAYS TAKEN
40007c0c:	b0 10 20 00 	clr  %i0                                       
   return 0;                                                          
#endif                                                                
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
}                                                                     
40007c10:	81 c7 e0 08 	ret                                            
40007c14:	81 e8 00 00 	restore                                        
  int name                                                            
)                                                                     
{                                                                     
  if ( name == _SC_CLK_TCK )                                          
    return (TOD_MICROSECONDS_PER_SECOND /                             
      rtems_configuration_get_microseconds_per_tick());               
40007c18:	03 10 00 5a 	sethi  %hi(0x40016800), %g1                    
long sysconf(                                                         
  int name                                                            
)                                                                     
{                                                                     
  if ( name == _SC_CLK_TCK )                                          
    return (TOD_MICROSECONDS_PER_SECOND /                             
40007c1c:	d2 00 62 b4 	ld  [ %g1 + 0x2b4 ], %o1	! 40016ab4 <Configuration+0xc>
40007c20:	11 00 03 d0 	sethi  %hi(0xf4000), %o0                       
40007c24:	40 00 32 7c 	call  40014614 <.udiv>                         
40007c28:	90 12 22 40 	or  %o0, 0x240, %o0	! f4240 <PROM_START+0xf4240>
40007c2c:	81 c7 e0 08 	ret                                            
40007c30:	91 e8 00 08 	restore  %g0, %o0, %o0                         
      rtems_configuration_get_microseconds_per_tick());               
                                                                      
  if ( name == _SC_OPEN_MAX )                                         
    return rtems_libio_number_iops;                                   
40007c34:	03 10 00 60 	sethi  %hi(0x40018000), %g1                    
40007c38:	f0 00 62 e8 	ld  [ %g1 + 0x2e8 ], %i0	! 400182e8 <rtems_libio_number_iops>
40007c3c:	81 c7 e0 08 	ret                                            
40007c40:	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 );                     
40007c44:	40 00 23 23 	call  400108d0 <__errno>                       
40007c48:	b0 10 3f ff 	mov  -1, %i0                                   
40007c4c:	82 10 20 16 	mov  0x16, %g1                                 
40007c50:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
40007c54:	81 c7 e0 08 	ret                                            
40007c58:	81 e8 00 00 	restore                                        
                                                                      

40016f10 <tcsetattr>: int tcsetattr( int fd, int opt, struct termios *tp ) {
40016f10:	9d e3 bf a0 	save  %sp, -96, %sp                            
  switch (opt) {                                                      
40016f14:	80 a6 60 00 	cmp  %i1, 0                                    
40016f18:	02 80 00 10 	be  40016f58 <tcsetattr+0x48>                  
40016f1c:	80 a6 60 01 	cmp  %i1, 1                                    
40016f20:	02 80 00 08 	be  40016f40 <tcsetattr+0x30>                  
40016f24:	90 10 00 18 	mov  %i0, %o0                                  
  default:                                                            
    rtems_set_errno_and_return_minus_one( ENOTSUP );                  
40016f28:	40 00 11 f0 	call  4001b6e8 <__errno>                       
40016f2c:	01 00 00 00 	nop                                            
40016f30:	82 10 20 86 	mov  0x86, %g1	! 86 <PROM_START+0x86>          
40016f34:	c2 22 00 00 	st  %g1, [ %o0 ]                               
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
  }                                                                   
}                                                                     
40016f38:	81 c7 e0 08 	ret                                            
40016f3c:	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)                      
40016f40:	92 10 20 03 	mov  3, %o1                                    
40016f44:	40 00 0e 52 	call  4001a88c <ioctl>                         
40016f48:	94 10 20 00 	clr  %o2                                       
40016f4c:	80 a2 20 00 	cmp  %o0, 0                                    
40016f50:	06 bf ff fa 	bl  40016f38 <tcsetattr+0x28>                  <== NEVER TAKEN
40016f54:	01 00 00 00 	nop                                            
    	return -1;                                                       
    /*                                                                
     * Fall through to....                                            
     */                                                               
  case TCSANOW:                                                       
    return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );                  
40016f58:	40 00 0e 4d 	call  4001a88c <ioctl>                         
40016f5c:	93 e8 20 02 	restore  %g0, 2, %o1                           
                                                                      

40009450 <timer_create>: int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) {
40009450:	9d e3 bf a0 	save  %sp, -96, %sp                            
  POSIX_Timer_Control *ptimer;                                        
                                                                      
  if ( clock_id != CLOCK_REALTIME )                                   
40009454:	80 a6 20 01 	cmp  %i0, 1                                    
40009458:	12 80 00 3d 	bne  4000954c <timer_create+0xfc>              
4000945c:	80 a6 a0 00 	cmp  %i2, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( !timerid )                                                     
40009460:	02 80 00 3b 	be  4000954c <timer_create+0xfc>               
40009464:	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) {                                                  
40009468:	02 80 00 0e 	be  400094a0 <timer_create+0x50>               
4000946c:	03 10 00 93 	sethi  %hi(0x40024c00), %g1                    
    /* The structure has data */                                      
    if ( ( evp->sigev_notify != SIGEV_NONE ) &&                       
40009470:	c2 06 40 00 	ld  [ %i1 ], %g1                               
40009474:	82 00 7f ff 	add  %g1, -1, %g1                              
40009478:	80 a0 60 01 	cmp  %g1, 1                                    
4000947c:	18 80 00 34 	bgu  4000954c <timer_create+0xfc>              <== NEVER TAKEN
40009480:	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 )                                         
40009484:	c2 06 60 04 	ld  [ %i1 + 4 ], %g1                           
40009488:	80 a0 60 00 	cmp  %g1, 0                                    
4000948c:	02 80 00 30 	be  4000954c <timer_create+0xfc>               <== NEVER TAKEN
40009490:	82 00 7f ff 	add  %g1, -1, %g1                              
       rtems_set_errno_and_return_minus_one( EINVAL );                
                                                                      
     if ( !is_valid_signo(evp->sigev_signo) )                         
40009494:	80 a0 60 1f 	cmp  %g1, 0x1f                                 
40009498:	18 80 00 2d 	bgu  4000954c <timer_create+0xfc>              <== NEVER TAKEN
4000949c:	03 10 00 93 	sethi  %hi(0x40024c00), %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;                  
400094a0:	c4 00 60 b0 	ld  [ %g1 + 0xb0 ], %g2	! 40024cb0 <_Thread_Dispatch_disable_level>
                                                                      
    ++level;                                                          
400094a4:	84 00 a0 01 	inc  %g2                                       
    _Thread_Dispatch_disable_level = level;                           
400094a8:	c4 20 60 b0 	st  %g2, [ %g1 + 0xb0 ]                        
 *  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 );
400094ac:	3b 10 00 93 	sethi  %hi(0x40024c00), %i5                    
400094b0:	40 00 08 e0 	call  4000b830 <_Objects_Allocate>             
400094b4:	90 17 63 b4 	or  %i5, 0x3b4, %o0	! 40024fb4 <_POSIX_Timer_Information>
                                                                      
  /*                                                                  
   *  Allocate a timer                                                
   */                                                                 
  ptimer = _POSIX_Timer_Allocate();                                   
  if ( !ptimer ) {                                                    
400094b8:	80 a2 20 00 	cmp  %o0, 0                                    
400094bc:	02 80 00 2a 	be  40009564 <timer_create+0x114>              
400094c0:	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;                   
400094c4:	c2 2a 20 3c 	stb  %g1, [ %o0 + 0x3c ]                       
  ptimer->thread_id = _Thread_Executing->Object.id;                   
400094c8:	03 10 00 94 	sethi  %hi(0x40025000), %g1                    
400094cc:	c2 00 62 10 	ld  [ %g1 + 0x210 ], %g1	! 40025210 <_Per_CPU_Information+0x10>
                                                                      
  if ( evp != NULL ) {                                                
400094d0:	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;                   
400094d4:	c2 00 60 08 	ld  [ %g1 + 8 ], %g1                           
                                                                      
  if ( evp != NULL ) {                                                
400094d8:	02 80 00 08 	be  400094f8 <timer_create+0xa8>               
400094dc:	c2 22 20 38 	st  %g1, [ %o0 + 0x38 ]                        
    ptimer->inf.sigev_notify = evp->sigev_notify;                     
400094e0:	c6 06 40 00 	ld  [ %i1 ], %g3                               
    ptimer->inf.sigev_signo  = evp->sigev_signo;                      
400094e4:	c4 06 60 04 	ld  [ %i1 + 4 ], %g2                           
    ptimer->inf.sigev_value  = evp->sigev_value;                      
400094e8:	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;                     
400094ec:	c6 22 20 40 	st  %g3, [ %o0 + 0x40 ]                        
    ptimer->inf.sigev_signo  = evp->sigev_signo;                      
400094f0:	c4 22 20 44 	st  %g2, [ %o0 + 0x44 ]                        
    ptimer->inf.sigev_value  = evp->sigev_value;                      
400094f4:	c2 22 20 48 	st  %g1, [ %o0 + 0x48 ]                        
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
400094f8:	c4 12 20 0a 	lduh  [ %o0 + 0xa ], %g2                       
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
400094fc:	ba 17 63 b4 	or  %i5, 0x3b4, %i5                            
40009500:	c6 07 60 1c 	ld  [ %i5 + 0x1c ], %g3                        
  }                                                                   
                                                                      
  ptimer->overrun  = 0;                                               
40009504:	c0 22 20 68 	clr  [ %o0 + 0x68 ]                            
  ptimer->timer_data.it_value.tv_sec     = 0;                         
40009508:	c0 22 20 5c 	clr  [ %o0 + 0x5c ]                            
  ptimer->timer_data.it_value.tv_nsec    = 0;                         
4000950c:	c0 22 20 60 	clr  [ %o0 + 0x60 ]                            
  ptimer->timer_data.it_interval.tv_sec  = 0;                         
40009510:	c0 22 20 54 	clr  [ %o0 + 0x54 ]                            
  ptimer->timer_data.it_interval.tv_nsec = 0;                         
40009514:	c0 22 20 58 	clr  [ %o0 + 0x58 ]                            
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
40009518:	c0 22 20 18 	clr  [ %o0 + 0x18 ]                            
  the_watchdog->routine   = routine;                                  
4000951c:	c0 22 20 2c 	clr  [ %o0 + 0x2c ]                            
  the_watchdog->id        = id;                                       
40009520:	c0 22 20 30 	clr  [ %o0 + 0x30 ]                            
  the_watchdog->user_data = user_data;                                
40009524:	c0 22 20 34 	clr  [ %o0 + 0x34 ]                            
  Objects_Information *information,                                   
  Objects_Control     *the_object,                                    
  uint32_t             name                                           
)                                                                     
{                                                                     
  _Objects_Set_local_object(                                          
40009528:	c2 02 20 08 	ld  [ %o0 + 8 ], %g1                           
  #if defined(RTEMS_DEBUG)                                            
    if ( index > information->maximum )                               
      return;                                                         
  #endif                                                              
                                                                      
  information->local_table[ index ] = the_object;                     
4000952c:	85 28 a0 02 	sll  %g2, 2, %g2                               
40009530:	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;                                   
40009534:	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;                                      
40009538:	c2 26 80 00 	st  %g1, [ %i2 ]                               
  _Thread_Enable_dispatch();                                          
4000953c:	40 00 0e 09 	call  4000cd60 <_Thread_Enable_dispatch>       
40009540:	b0 10 20 00 	clr  %i0                                       
  return 0;                                                           
}                                                                     
40009544:	81 c7 e0 08 	ret                                            
40009548:	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 );                
4000954c:	40 00 24 c4 	call  4001285c <__errno>                       
40009550:	b0 10 3f ff 	mov  -1, %i0                                   
40009554:	82 10 20 16 	mov  0x16, %g1                                 
40009558:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000955c:	81 c7 e0 08 	ret                                            
40009560:	81 e8 00 00 	restore                                        
  /*                                                                  
   *  Allocate a timer                                                
   */                                                                 
  ptimer = _POSIX_Timer_Allocate();                                   
  if ( !ptimer ) {                                                    
    _Thread_Enable_dispatch();                                        
40009564:	40 00 0d ff 	call  4000cd60 <_Thread_Enable_dispatch>       
40009568:	b0 10 3f ff 	mov  -1, %i0                                   
    rtems_set_errno_and_return_minus_one( EAGAIN );                   
4000956c:	40 00 24 bc 	call  4001285c <__errno>                       
40009570:	01 00 00 00 	nop                                            
40009574:	82 10 20 0b 	mov  0xb, %g1	! b <PROM_START+0xb>             
40009578:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4000957c:	81 c7 e0 08 	ret                                            
40009580:	81 e8 00 00 	restore                                        
                                                                      

400080a8 <timer_settime>: timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) {
400080a8:	9d e3 bf 78 	save  %sp, -136, %sp                           
  Objects_Locations    location;                                      
  bool                 activated;                                     
  uint32_t             initial_period;                                
  struct itimerspec    normalize;                                     
                                                                      
  if ( !value )                                                       
400080ac:	80 a6 a0 00 	cmp  %i2, 0                                    
400080b0:	02 80 00 86 	be  400082c8 <timer_settime+0x220>             <== NEVER TAKEN
400080b4:	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) ) ) {                  
400080b8:	40 00 10 37 	call  4000c194 <_Timespec_Is_valid>            
400080bc:	90 06 a0 08 	add  %i2, 8, %o0                               
400080c0:	80 8a 20 ff 	btst  0xff, %o0                                
400080c4:	02 80 00 81 	be  400082c8 <timer_settime+0x220>             
400080c8:	01 00 00 00 	nop                                            
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
  if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {               
400080cc:	40 00 10 32 	call  4000c194 <_Timespec_Is_valid>            
400080d0:	90 10 00 1a 	mov  %i2, %o0                                  
400080d4:	80 8a 20 ff 	btst  0xff, %o0                                
400080d8:	02 80 00 7c 	be  400082c8 <timer_settime+0x220>             <== NEVER TAKEN
400080dc:	80 8e 7f fb 	btst  -5, %i1                                  
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {    
400080e0:	12 80 00 7a 	bne  400082c8 <timer_settime+0x220>            
400080e4:	80 a6 60 04 	cmp  %i1, 4                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
  }                                                                   
                                                                      
  normalize = *value;                                                 
400080e8:	c8 06 80 00 	ld  [ %i2 ], %g4                               
400080ec:	c6 06 a0 04 	ld  [ %i2 + 4 ], %g3                           
400080f0:	c4 06 a0 08 	ld  [ %i2 + 8 ], %g2                           
400080f4:	c2 06 a0 0c 	ld  [ %i2 + 0xc ], %g1                         
400080f8:	c8 27 bf f0 	st  %g4, [ %fp + -16 ]                         
400080fc:	c6 27 bf f4 	st  %g3, [ %fp + -12 ]                         
40008100:	c4 27 bf f8 	st  %g2, [ %fp + -8 ]                          
                                                                      
  /* Convert absolute to relative time */                             
  if (flags == TIMER_ABSTIME) {                                       
40008104:	02 80 00 4c 	be  40008234 <timer_settime+0x18c>             
40008108:	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 *)                                      
4000810c:	92 10 00 18 	mov  %i0, %o1                                  
40008110:	11 10 00 84 	sethi  %hi(0x40021000), %o0                    
40008114:	94 07 bf dc 	add  %fp, -36, %o2                             
40008118:	40 00 09 ba 	call  4000a800 <_Objects_Get>                  
4000811c:	90 12 20 c4 	or  %o0, 0xc4, %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 ) {                                               
40008120:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
40008124:	80 a0 60 00 	cmp  %g1, 0                                    
40008128:	12 80 00 68 	bne  400082c8 <timer_settime+0x220>            <== NEVER TAKEN
4000812c:	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 ) {
40008130:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
40008134:	80 a0 60 00 	cmp  %g1, 0                                    
40008138:	12 80 00 05 	bne  4000814c <timer_settime+0xa4>             
4000813c:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008140:	80 a0 60 00 	cmp  %g1, 0                                    
40008144:	02 80 00 67 	be  400082e0 <timer_settime+0x238>             
40008148:	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 );    
4000814c:	40 00 10 4b 	call  4000c278 <_Timespec_To_ticks>            
40008150:	90 10 00 1a 	mov  %i2, %o0                                  
40008154:	d0 26 60 64 	st  %o0, [ %i1 + 0x64 ]                        
       initial_period = _Timespec_To_ticks( &normalize.it_value );    
40008158:	40 00 10 48 	call  4000c278 <_Timespec_To_ticks>            
4000815c:	90 07 bf f8 	add  %fp, -8, %o0                              
                                                                      
                                                                      
       activated = _POSIX_Timer_Insert_helper(                        
40008160:	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 );    
40008164:	92 10 00 08 	mov  %o0, %o1                                  
                                                                      
                                                                      
       activated = _POSIX_Timer_Insert_helper(                        
40008168:	98 10 00 19 	mov  %i1, %o4                                  
4000816c:	90 06 60 10 	add  %i1, 0x10, %o0                            
40008170:	17 10 00 20 	sethi  %hi(0x40008000), %o3                    
40008174:	40 00 19 f7 	call  4000e950 <_POSIX_Timer_Insert_helper>    
40008178:	96 12 e3 4c 	or  %o3, 0x34c, %o3	! 4000834c <_POSIX_Timer_TSR>
         initial_period,                                              
         ptimer->Object.id,                                           
         _POSIX_Timer_TSR,                                            
         ptimer                                                       
       );                                                             
       if ( !activated ) {                                            
4000817c:	80 8a 20 ff 	btst  0xff, %o0                                
40008180:	02 80 00 29 	be  40008224 <timer_settime+0x17c>             
40008184:	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 )                                                  
40008188:	02 80 00 0b 	be  400081b4 <timer_settime+0x10c>             
4000818c:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
         *ovalue = ptimer->timer_data;                                
40008190:	c2 06 60 54 	ld  [ %i1 + 0x54 ], %g1                        
40008194:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
40008198:	c2 06 60 58 	ld  [ %i1 + 0x58 ], %g1                        
4000819c:	c2 26 e0 04 	st  %g1, [ %i3 + 4 ]                           
400081a0:	c2 06 60 5c 	ld  [ %i1 + 0x5c ], %g1                        
400081a4:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           
400081a8:	c2 06 60 60 	ld  [ %i1 + 0x60 ], %g1                        
400081ac:	c2 26 e0 0c 	st  %g1, [ %i3 + 0xc ]                         
       ptimer->timer_data = normalize;                                
400081b0:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
)                                                                     
{                                                                     
  Timestamp_Control  tod_as_timestamp;                                
  Timestamp_Control *tod_as_timestamp_ptr;                            
                                                                      
  tod_as_timestamp_ptr =                                              
400081b4:	90 07 bf e0 	add  %fp, -32, %o0                             
400081b8:	c2 26 60 54 	st  %g1, [ %i1 + 0x54 ]                        
400081bc:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
400081c0:	13 10 00 83 	sethi  %hi(0x40020c00), %o1                    
400081c4:	c2 26 60 58 	st  %g1, [ %i1 + 0x58 ]                        
400081c8:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
400081cc:	92 12 61 48 	or  %o1, 0x148, %o1                            
400081d0:	c2 26 60 5c 	st  %g1, [ %i1 + 0x5c ]                        
400081d4:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
400081d8:	c2 26 60 60 	st  %g1, [ %i1 + 0x60 ]                        
                                                                      
       /* Indicate that the time is running */                        
       ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;                  
400081dc:	82 10 20 03 	mov  3, %g1                                    
400081e0:	40 00 06 b4 	call  40009cb0 <_TOD_Get_with_nanoseconds>     
400081e4:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
}                                                                     
400081e8:	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);           
400081ec:	94 10 20 00 	clr  %o2                                       
400081f0:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
400081f4:	90 10 00 1c 	mov  %i4, %o0                                  
400081f8:	96 12 e2 00 	or  %o3, 0x200, %o3                            
400081fc:	40 00 4a ad 	call  4001acb0 <__divdi3>                      
40008200:	92 10 00 1d 	mov  %i5, %o1                                  
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40008204:	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);           
40008208:	d2 26 60 6c 	st  %o1, [ %i1 + 0x6c ]                        
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
4000820c:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40008210:	90 10 00 1c 	mov  %i4, %o0                                  
40008214:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40008218:	40 00 4b 91 	call  4001b05c <__moddi3>                      
4000821c:	92 10 00 1d 	mov  %i5, %o1                                  
40008220:	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();                                     
40008224:	40 00 0d 2e 	call  4000b6dc <_Thread_Enable_dispatch>       
40008228:	b0 10 20 00 	clr  %i0                                       
4000822c:	81 c7 e0 08 	ret                                            
40008230:	81 e8 00 00 	restore                                        
40008234:	90 07 bf e0 	add  %fp, -32, %o0                             
40008238:	13 10 00 83 	sethi  %hi(0x40020c00), %o1                    
4000823c:	40 00 06 9d 	call  40009cb0 <_TOD_Get_with_nanoseconds>     
40008240:	92 12 61 48 	or  %o1, 0x148, %o1	! 40020d48 <_TOD>          
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
}                                                                     
40008244:	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);           
40008248:	94 10 20 00 	clr  %o2                                       
4000824c:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
40008250:	90 10 00 1c 	mov  %i4, %o0                                  
40008254:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40008258:	40 00 4a 96 	call  4001acb0 <__divdi3>                      
4000825c:	92 10 00 1d 	mov  %i5, %o1                                  
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40008260:	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);           
40008264:	d2 27 bf e8 	st  %o1, [ %fp + -24 ]                         
  _timespec->tv_nsec = (long) (*_timestamp % 1000000000L);            
40008268:	17 0e e6 b2 	sethi  %hi(0x3b9ac800), %o3                    
4000826c:	90 10 00 1c 	mov  %i4, %o0                                  
40008270:	96 12 e2 00 	or  %o3, 0x200, %o3                            
40008274:	40 00 4b 7a 	call  4001b05c <__moddi3>                      
40008278:	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 ) )        
4000827c:	90 07 bf f8 	add  %fp, -8, %o0                              
40008280:	d2 27 bf ec 	st  %o1, [ %fp + -20 ]                         
40008284:	40 00 0f d7 	call  4000c1e0 <_Timespec_Less_than>           
40008288:	92 07 bf e8 	add  %fp, -24, %o1                             
4000828c:	80 8a 20 ff 	btst  0xff, %o0                                
40008290:	12 80 00 0e 	bne  400082c8 <timer_settime+0x220>            
40008294:	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 );
40008298:	90 07 bf e8 	add  %fp, -24, %o0                             
4000829c:	40 00 0f e3 	call  4000c228 <_Timespec_Subtract>            
400082a0:	94 10 00 09 	mov  %o1, %o2                                  
400082a4:	92 10 00 18 	mov  %i0, %o1                                  
400082a8:	11 10 00 84 	sethi  %hi(0x40021000), %o0                    
400082ac:	94 07 bf dc 	add  %fp, -36, %o2                             
400082b0:	40 00 09 54 	call  4000a800 <_Objects_Get>                  
400082b4:	90 12 20 c4 	or  %o0, 0xc4, %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 ) {                                               
400082b8:	c2 07 bf dc 	ld  [ %fp + -36 ], %g1                         
400082bc:	80 a0 60 00 	cmp  %g1, 0                                    
400082c0:	02 bf ff 9c 	be  40008130 <timer_settime+0x88>              
400082c4:	b2 10 00 08 	mov  %o0, %i1                                  
#endif                                                                
    case OBJECTS_ERROR:                                               
      break;                                                          
  }                                                                   
                                                                      
  rtems_set_errno_and_return_minus_one( EINVAL );                     
400082c8:	40 00 24 11 	call  4001130c <__errno>                       
400082cc:	b0 10 3f ff 	mov  -1, %i0                                   
400082d0:	82 10 20 16 	mov  0x16, %g1                                 
400082d4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
}                                                                     
400082d8:	81 c7 e0 08 	ret                                            
400082dc:	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 );                   
400082e0:	40 00 10 ef 	call  4000c69c <_Watchdog_Remove>              
400082e4:	90 02 20 10 	add  %o0, 0x10, %o0                            
         /* The old data of the timer are returned */                 
         if ( ovalue )                                                
400082e8:	80 a6 e0 00 	cmp  %i3, 0                                    
400082ec:	02 80 00 0b 	be  40008318 <timer_settime+0x270>             
400082f0:	c2 07 bf f0 	ld  [ %fp + -16 ], %g1                         
           *ovalue = ptimer->timer_data;                              
400082f4:	c2 06 60 54 	ld  [ %i1 + 0x54 ], %g1                        
400082f8:	c2 26 c0 00 	st  %g1, [ %i3 ]                               
400082fc:	c2 06 60 58 	ld  [ %i1 + 0x58 ], %g1                        
40008300:	c2 26 e0 04 	st  %g1, [ %i3 + 4 ]                           
40008304:	c2 06 60 5c 	ld  [ %i1 + 0x5c ], %g1                        
40008308:	c2 26 e0 08 	st  %g1, [ %i3 + 8 ]                           
4000830c:	c2 06 60 60 	ld  [ %i1 + 0x60 ], %g1                        
40008310:	c2 26 e0 0c 	st  %g1, [ %i3 + 0xc ]                         
         /* The new data are set */                                   
         ptimer->timer_data = normalize;                              
40008314:	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;                                                     
40008318:	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;                              
4000831c:	c2 26 60 54 	st  %g1, [ %i1 + 0x54 ]                        
40008320:	c2 07 bf f4 	ld  [ %fp + -12 ], %g1                         
40008324:	c2 26 60 58 	st  %g1, [ %i1 + 0x58 ]                        
40008328:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
4000832c:	c2 26 60 5c 	st  %g1, [ %i1 + 0x5c ]                        
40008330:	c2 07 bf fc 	ld  [ %fp + -4 ], %g1                          
40008334:	c2 26 60 60 	st  %g1, [ %i1 + 0x60 ]                        
         /* Indicates that the timer is created and stopped */        
         ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;               
40008338:	82 10 20 04 	mov  4, %g1                                    
         /* Returns with success */                                   
        _Thread_Enable_dispatch();                                    
4000833c:	40 00 0c e8 	call  4000b6dc <_Thread_Enable_dispatch>       
40008340:	c2 2e 60 3c 	stb  %g1, [ %i1 + 0x3c ]                       
40008344:	81 c7 e0 08 	ret                                            
40008348:	81 e8 00 00 	restore                                        
                                                                      

40007ff4 <ualarm>: useconds_t ualarm( useconds_t useconds, useconds_t interval ) {
40007ff4:	9d e3 bf 98 	save  %sp, -104, %sp                           
                                                                      
  /*                                                                  
   *  Initialize the timer used to implement alarm().                 
   */                                                                 
                                                                      
  if ( !the_timer->routine ) {                                        
40007ff8:	3b 10 00 6a 	sethi  %hi(0x4001a800), %i5                    
40007ffc:	ba 17 62 48 	or  %i5, 0x248, %i5	! 4001aa48 <_POSIX_signals_Ualarm_timer>
40008000:	c2 07 60 1c 	ld  [ %i5 + 0x1c ], %g1                        
40008004:	80 a0 60 00 	cmp  %g1, 0                                    
40008008:	02 80 00 24 	be  40008098 <ualarm+0xa4>                     
4000800c:	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 );                            
40008010:	40 00 10 8e 	call  4000c248 <_Watchdog_Remove>              
40008014:	90 10 00 1d 	mov  %i5, %o0                                  
    if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
40008018:	90 02 3f fe 	add  %o0, -2, %o0                              
4000801c:	80 a2 20 01 	cmp  %o0, 1                                    
40008020:	08 80 00 26 	bleu  400080b8 <ualarm+0xc4>                   <== ALWAYS TAKEN
40008024:	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 ) {                                                   
40008028:	80 a7 20 00 	cmp  %i4, 0                                    
4000802c:	02 80 00 19 	be  40008090 <ualarm+0x9c>                     
40008030:	37 00 03 d0 	sethi  %hi(0xf4000), %i3                       
    Watchdog_Interval ticks;                                          
                                                                      
    tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;               
40008034:	90 10 00 1c 	mov  %i4, %o0                                  
40008038:	40 00 37 2b 	call  40015ce4 <.udiv>                         
4000803c:	92 16 e2 40 	or  %i3, 0x240, %o1                            
    tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;     
40008040:	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;               
40008044:	d0 27 bf f8 	st  %o0, [ %fp + -8 ]                          
    tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;     
40008048:	40 00 37 d3 	call  40015f94 <.urem>                         
4000804c:	90 10 00 1c 	mov  %i4, %o0                                  
40008050:	87 2a 20 07 	sll  %o0, 7, %g3                               
40008054:	82 10 00 08 	mov  %o0, %g1                                  
40008058:	85 2a 20 02 	sll  %o0, 2, %g2                               
4000805c:	84 20 c0 02 	sub  %g3, %g2, %g2                             
40008060:	82 00 80 01 	add  %g2, %g1, %g1                             
40008064:	83 28 60 03 	sll  %g1, 3, %g1                               
    ticks = _Timespec_To_ticks( &tp );                                
40008068:	90 07 bf f8 	add  %fp, -8, %o0                              
4000806c:	40 00 0f 3e 	call  4000bd64 <_Timespec_To_ticks>            
40008070:	c2 27 bf fc 	st  %g1, [ %fp + -4 ]                          
    if ( ticks == 0 )                                                 
      ticks = 1;                                                      
                                                                      
    _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );   
40008074:	40 00 0f 3c 	call  4000bd64 <_Timespec_To_ticks>            
40008078:	90 07 bf f8 	add  %fp, -8, %o0                              
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
4000807c:	92 10 00 1d 	mov  %i5, %o1                                  
  Watchdog_Control      *the_watchdog,                                
  Watchdog_Interval      units                                        
)                                                                     
{                                                                     
                                                                      
  the_watchdog->initial = units;                                      
40008080:	d0 27 60 0c 	st  %o0, [ %i5 + 0xc ]                         
                                                                      
  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );           
40008084:	11 10 00 68 	sethi  %hi(0x4001a000), %o0                    
40008088:	40 00 10 11 	call  4000c0cc <_Watchdog_Insert>              
4000808c:	90 12 21 f8 	or  %o0, 0x1f8, %o0	! 4001a1f8 <_Watchdog_Ticks_chain>
  }                                                                   
                                                                      
  return remaining;                                                   
}                                                                     
40008090:	81 c7 e0 08 	ret                                            
40008094:	81 e8 00 00 	restore                                        
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
40008098:	03 10 00 1f 	sethi  %hi(0x40007c00), %g1                    
  Watchdog_Service_routine_entry  routine,                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
4000809c:	c0 27 60 08 	clr  [ %i5 + 8 ]                               
  the_watchdog->routine   = routine;                                  
400080a0:	82 10 63 c4 	or  %g1, 0x3c4, %g1                            
  the_watchdog->id        = id;                                       
400080a4:	c0 27 60 20 	clr  [ %i5 + 0x20 ]                            
  Objects_Id                      id,                                 
  void                           *user_data                           
)                                                                     
{                                                                     
  the_watchdog->state     = WATCHDOG_INACTIVE;                        
  the_watchdog->routine   = routine;                                  
400080a8:	c2 27 60 1c 	st  %g1, [ %i5 + 0x1c ]                        
  the_watchdog->id        = id;                                       
  the_watchdog->user_data = user_data;                                
400080ac:	c0 27 60 24 	clr  [ %i5 + 0x24 ]                            
useconds_t ualarm(                                                    
  useconds_t useconds,                                                
  useconds_t interval                                                 
)                                                                     
{                                                                     
  useconds_t        remaining = 0;                                    
400080b0:	10 bf ff de 	b  40008028 <ualarm+0x34>                      
400080b4:	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);        
400080b8:	c4 07 60 0c 	ld  [ %i5 + 0xc ], %g2                         
400080bc:	c2 07 60 18 	ld  [ %i5 + 0x18 ], %g1                        
400080c0:	d0 07 60 14 	ld  [ %i5 + 0x14 ], %o0                        
      /* remaining is now in ticks */                                 
                                                                      
      _Timespec_From_ticks( ticks, &tp );                             
400080c4:	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);        
400080c8:	90 02 00 02 	add  %o0, %g2, %o0                             
      /* remaining is now in ticks */                                 
                                                                      
      _Timespec_From_ticks( ticks, &tp );                             
400080cc:	40 00 0f 11 	call  4000bd10 <_Timespec_From_ticks>          
400080d0:	90 22 00 01 	sub  %o0, %g1, %o0                             
      remaining  = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;           
400080d4:	c2 07 bf f8 	ld  [ %fp + -8 ], %g1                          
      remaining += tp.tv_nsec / 1000;                                 
400080d8:	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;           
400080dc:	85 28 60 03 	sll  %g1, 3, %g2                               
400080e0:	87 28 60 08 	sll  %g1, 8, %g3                               
400080e4:	84 20 c0 02 	sub  %g3, %g2, %g2                             
      remaining += tp.tv_nsec / 1000;                                 
400080e8:	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;           
400080ec:	b1 28 a0 06 	sll  %g2, 6, %i0                               
400080f0:	b0 26 00 02 	sub  %i0, %g2, %i0                             
      remaining += tp.tv_nsec / 1000;                                 
400080f4:	40 00 36 fe 	call  40015cec <.div>                          
400080f8:	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;           
400080fc:	b1 2e 20 06 	sll  %i0, 6, %i0                               
      remaining += tp.tv_nsec / 1000;                                 
40008100:	10 bf ff ca 	b  40008028 <ualarm+0x34>                      
40008104:	b0 02 00 18 	add  %o0, %i0, %i0                             
                                                                      

40007a8c <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 ) {
40007a8c:	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 =                
40007a90:	94 10 20 18 	mov  0x18, %o2                                 
40007a94:	92 10 00 18 	mov  %i0, %o1                                  
40007a98:	7f ff f6 9e 	call  40005510 <rtems_filesystem_eval_path_start>
40007a9c:	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;
40007aa0:	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)(                         
40007aa4:	c2 07 60 0c 	ld  [ %i5 + 0xc ], %g1                         
40007aa8:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1                        
40007aac:	9f c0 40 00 	call  %g1                                      
40007ab0:	d2 07 60 24 	ld  [ %i5 + 0x24 ], %o1                        
                                                                      
  if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {   
40007ab4:	80 8a 20 ff 	btst  0xff, %o0                                
40007ab8:	02 80 00 33 	be  40007b84 <unmount+0xf8>                    
40007abc:	03 10 00 5e 	sethi  %hi(0x40017800), %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;                                 
40007ac0:	c2 00 60 10 	ld  [ %g1 + 0x10 ], %g1	! 40017810 <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; 
40007ac4:	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;                              
40007ac8:	c6 00 40 00 	ld  [ %g1 ], %g3                               
                                                                      
  return mt_entry == root->mt_entry || mt_entry == current->mt_entry; 
40007acc:	c2 00 a0 14 	ld  [ %g2 + 0x14 ], %g1                        
40007ad0:	80 a7 40 01 	cmp  %i5, %g1                                  
40007ad4:	02 80 00 27 	be  40007b70 <unmount+0xe4>                    
40007ad8:	01 00 00 00 	nop                                            
40007adc:	c2 00 e0 14 	ld  [ %g3 + 0x14 ], %g1                        
40007ae0:	80 a7 40 01 	cmp  %i5, %g1                                  
40007ae4:	02 80 00 23 	be  40007b70 <unmount+0xe4>                    
40007ae8:	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;              
40007aec:	c2 07 60 20 	ld  [ %i5 + 0x20 ], %g1                        
40007af0:	c2 00 60 14 	ld  [ %g1 + 0x14 ], %g1                        
                                                                      
      rv = (*mt_point_ops->unmount_h)( mt_entry );                    
40007af4:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40007af8:	c2 00 60 38 	ld  [ %g1 + 0x38 ], %g1                        
40007afc:	9f c0 40 00 	call  %g1                                      
40007b00:	90 10 00 1d 	mov  %i5, %o0                                  
      if ( rv == 0 ) {                                                
40007b04:	b0 92 20 00 	orcc  %o0, 0, %i0                              
40007b08:	02 80 00 06 	be  40007b20 <unmount+0x94>                    
40007b0c:	01 00 00 00 	nop                                            
  } else {                                                            
    errno = EACCES;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40007b10:	7f ff f6 c0 	call  40005610 <rtems_filesystem_eval_path_cleanup>
40007b14:	90 07 bf c8 	add  %fp, -56, %o0                             
      rtems_fatal_error_occurred( 0xdeadbeef );                       
    }                                                                 
  }                                                                   
                                                                      
  return rv;                                                          
}                                                                     
40007b18:	81 c7 e0 08 	ret                                            
40007b1c:	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();                    
40007b20:	40 00 04 48 	call  40008c40 <rtems_task_self>               
40007b24:	01 00 00 00 	nop                                            
        rtems_filesystem_mt_entry_declare_lock_context( lock_context );
                                                                      
        rtems_filesystem_mt_entry_lock( lock_context );               
40007b28:	7f ff ea 54 	call  40002478 <sparc_disable_interrupts>      
40007b2c:	b8 10 00 08 	mov  %o0, %i4                                  
        mt_entry->unmount_task = self_task_id;                        
40007b30:	f8 27 60 3c 	st  %i4, [ %i5 + 0x3c ]                        
        mt_entry->mounted = false;                                    
40007b34:	c0 2f 60 28 	clrb  [ %i5 + 0x28 ]                           
        rtems_filesystem_mt_entry_unlock( lock_context );             
40007b38:	7f ff ea 54 	call  40002488 <sparc_enable_interrupts>       
40007b3c:	01 00 00 00 	nop                                            
  } else {                                                            
    errno = EACCES;                                                   
    rv = -1;                                                          
  }                                                                   
                                                                      
  rtems_filesystem_eval_path_cleanup( &ctx );                         
40007b40:	7f ff f6 b4 	call  40005610 <rtems_filesystem_eval_path_cleanup>
40007b44:	90 07 bf c8 	add  %fp, -56, %o0                             
  rtems_interval ticks                                                
)                                                                     
{                                                                     
  rtems_event_set event_out;                                          
                                                                      
  return rtems_event_system_receive(                                  
40007b48:	11 20 00 00 	sethi  %hi(0x80000000), %o0                    
40007b4c:	92 10 20 00 	clr  %o1                                       
40007b50:	94 10 20 00 	clr  %o2                                       
40007b54:	40 00 03 78 	call  40008934 <rtems_event_system_receive>    
40007b58:	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 ) {                                   
40007b5c:	80 a2 20 00 	cmp  %o0, 0                                    
40007b60:	02 bf ff ee 	be  40007b18 <unmount+0x8c>                    <== ALWAYS TAKEN
40007b64:	11 37 ab 6f 	sethi  %hi(0xdeadbc00), %o0                    
      rtems_fatal_error_occurred( 0xdeadbeef );                       
40007b68:	40 00 04 da 	call  40008ed0 <rtems_fatal_error_occurred>    <== NOT EXECUTED
40007b6c:	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;                                                  
40007b70:	40 00 23 b0 	call  40010a30 <__errno>                       
40007b74:	b0 10 3f ff 	mov  -1, %i0                                   
40007b78:	82 10 20 10 	mov  0x10, %g1                                 
40007b7c:	10 bf ff e5 	b  40007b10 <unmount+0x84>                     
40007b80:	c2 22 00 00 	st  %g1, [ %o0 ]                               
      rv = -1;                                                        
    }                                                                 
  } else {                                                            
    errno = EACCES;                                                   
40007b84:	40 00 23 ab 	call  40010a30 <__errno>                       
40007b88:	b0 10 3f ff 	mov  -1, %i0                                   
40007b8c:	82 10 20 0d 	mov  0xd, %g1                                  
40007b90:	10 bf ff e0 	b  40007b10 <unmount+0x84>                     
40007b94:	c2 22 00 00 	st  %g1, [ %o0 ]                               
                                                                      

40007a68 <vprintk>: */ void vprintk( const char *fmt, va_list ap ) {
40007a68:	9d e3 bf 88 	save  %sp, -120, %sp                           
  for (; *fmt != '\0'; fmt++) {                                       
40007a6c:	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(                                                         
40007a70:	a0 07 bf e8 	add  %fp, -24, %l0                             
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40007a74:	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(                                                         
40007a78:	a2 07 bf e7 	add  %fp, -25, %l1                             
40007a7c:	25 10 00 78 	sethi  %hi(0x4001e000), %l2                    
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40007a80:	80 a2 20 00 	cmp  %o0, 0                                    
40007a84:	02 80 00 74 	be  40007c54 <vprintk+0x1ec>                   <== NEVER TAKEN
40007a88:	27 10 00 78 	sethi  %hi(0x4001e000), %l3                    
    bool minus = false;                                               
    bool sign = false;                                                
    char lead = ' ';                                                  
    char c;                                                           
                                                                      
    if (*fmt != '%') {                                                
40007a8c:	91 3a 20 18 	sra  %o0, 0x18, %o0                            
40007a90:	80 a2 20 25 	cmp  %o0, 0x25                                 
40007a94:	12 80 00 7a 	bne  40007c7c <vprintk+0x214>                  
40007a98:	01 00 00 00 	nop                                            
      rtems_putc(*fmt);                                               
      continue;                                                       
    }                                                                 
    fmt++;                                                            
    if (*fmt == '0' ) {                                               
40007a9c:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
40007aa0:	85 28 60 18 	sll  %g1, 0x18, %g2                            
40007aa4:	87 38 a0 18 	sra  %g2, 0x18, %g3                            
40007aa8:	80 a0 e0 30 	cmp  %g3, 0x30                                 
40007aac:	22 80 00 a9 	be,a   40007d50 <vprintk+0x2e8>                
40007ab0:	c2 0e 20 02 	ldub  [ %i0 + 2 ], %g1                         
                                                                      
    if (*fmt != '%') {                                                
      rtems_putc(*fmt);                                               
      continue;                                                       
    }                                                                 
    fmt++;                                                            
40007ab4:	b0 06 20 01 	inc  %i0                                       
    unsigned base = 0;                                                
    unsigned width = 0;                                               
    bool lflag = false;                                               
    bool minus = false;                                               
    bool sign = false;                                                
    char lead = ' ';                                                  
40007ab8:	a8 10 20 20 	mov  0x20, %l4                                 
    fmt++;                                                            
    if (*fmt == '0' ) {                                               
      lead = '0';                                                     
      fmt++;                                                          
    }                                                                 
    if (*fmt == '-' ) {                                               
40007abc:	87 38 a0 18 	sra  %g2, 0x18, %g3                            
40007ac0:	80 a0 e0 2d 	cmp  %g3, 0x2d                                 
40007ac4:	02 80 00 9e 	be  40007d3c <vprintk+0x2d4>                   
40007ac8:	88 10 20 00 	clr  %g4                                       
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
40007acc:	86 00 7f d0 	add  %g1, -48, %g3                             
40007ad0:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
40007ad4:	80 a0 e0 09 	cmp  %g3, 9                                    
40007ad8:	18 80 00 0f 	bgu  40007b14 <vprintk+0xac>                   
40007adc:	ba 10 20 00 	clr  %i5                                       
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
      fmt++;                                                          
40007ae0:	b0 06 20 01 	inc  %i0                                       
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
40007ae4:	c2 0e 00 00 	ldub  [ %i0 ], %g1                             
      width *= 10;                                                    
40007ae8:	87 2f 60 01 	sll  %i5, 1, %g3                               
      width += ((unsigned) *fmt - '0');                               
40007aec:	85 38 a0 18 	sra  %g2, 0x18, %g2                            
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
      width *= 10;                                                    
40007af0:	bb 2f 60 03 	sll  %i5, 3, %i5                               
40007af4:	ba 00 c0 1d 	add  %g3, %i5, %i5                             
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
40007af8:	86 00 7f d0 	add  %g1, -48, %g3                             
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
40007afc:	ba 07 40 02 	add  %i5, %g2, %i5                             
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
40007b00:	86 08 e0 ff 	and  %g3, 0xff, %g3                            
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
40007b04:	ba 07 7f d0 	add  %i5, -48, %i5                             
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
      fmt++;                                                          
    }                                                                 
    while (*fmt >= '0' && *fmt <= '9' ) {                             
40007b08:	80 a0 e0 09 	cmp  %g3, 9                                    
40007b0c:	08 bf ff f5 	bleu  40007ae0 <vprintk+0x78>                  
40007b10:	85 28 60 18 	sll  %g1, 0x18, %g2                            
      width *= 10;                                                    
      width += ((unsigned) *fmt - '0');                               
      fmt++;                                                          
    }                                                                 
                                                                      
    if ((c = *fmt) == 'l') {                                          
40007b14:	87 38 a0 18 	sra  %g2, 0x18, %g3                            
40007b18:	80 a0 e0 6c 	cmp  %g3, 0x6c                                 
40007b1c:	02 80 00 77 	be  40007cf8 <vprintk+0x290>                   
40007b20:	91 38 a0 18 	sra  %g2, 0x18, %o0                            
      lflag = true;                                                   
      c = *++fmt;                                                     
    }                                                                 
    if ( c == 'c' ) {                                                 
40007b24:	80 a2 20 63 	cmp  %o0, 0x63                                 
40007b28:	22 80 00 7b 	be,a   40007d14 <vprintk+0x2ac>                
40007b2c:	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' ) {                                                 
40007b30:	80 a2 20 73 	cmp  %o0, 0x73                                 
40007b34:	02 80 00 8b 	be  40007d60 <vprintk+0x2f8>                   
40007b38:	82 08 7f df 	and  %g1, -33, %g1                             
                                                                      
      continue;                                                       
    }                                                                 
                                                                      
    /* must be a numeric format or something unsupported */           
    if ( c == 'o' || c == 'O' ) {                                     
40007b3c:	83 28 60 18 	sll  %g1, 0x18, %g1                            
40007b40:	83 38 60 18 	sra  %g1, 0x18, %g1                            
40007b44:	80 a0 60 4f 	cmp  %g1, 0x4f                                 
40007b48:	22 80 00 55 	be,a   40007c9c <vprintk+0x234>                
40007b4c:	f4 06 40 00 	ld  [ %i1 ], %i2                               
      base = 8; sign = false;                                         
    } else if ( c == 'i' || c == 'I' ||                               
40007b50:	80 a0 60 49 	cmp  %g1, 0x49                                 
40007b54:	22 80 00 06 	be,a   40007b6c <vprintk+0x104>                
40007b58:	82 10 20 01 	mov  1, %g1                                    
                c == 'd' || c == 'D' ) {                              
40007b5c:	80 a0 60 44 	cmp  %g1, 0x44                                 
40007b60:	12 80 00 3f 	bne  40007c5c <vprintk+0x1f4>                  
40007b64:	80 a0 60 55 	cmp  %g1, 0x55                                 
      base = 10; sign = true;                                         
40007b68:	82 10 20 01 	mov  1, %g1                                    
40007b6c:	aa 10 20 0a 	mov  0xa, %l5                                  
    } else {                                                          
      rtems_putc(c);                                                  
      continue;                                                       
    }                                                                 
                                                                      
    printNum(                                                         
40007b70:	f4 06 40 00 	ld  [ %i1 ], %i2                               
  unsigned long unsigned_num;                                         
  unsigned long n;                                                    
  unsigned count;                                                     
  char toPrint[20];                                                   
                                                                      
  if ( sign && (num <  0) ) {                                         
40007b74:	80 a6 a0 00 	cmp  %i2, 0                                    
40007b78:	06 80 00 4e 	bl  40007cb0 <vprintk+0x248>                   
40007b7c:	b2 06 60 04 	add  %i1, 4, %i1                               
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
40007b80:	90 10 00 1a 	mov  %i2, %o0                                  
40007b84:	40 00 47 bc 	call  40019a74 <.udiv>                         
40007b88:	92 10 00 15 	mov  %l5, %o1                                  
40007b8c:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40007b90:	22 80 00 57 	be,a   40007cec <vprintk+0x284>                
40007b94:	b8 10 00 1a 	mov  %i2, %i4                                  
40007b98:	ac 10 00 15 	mov  %l5, %l6                                  
    if (maxwidth) maxwidth--;                                         
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
40007b9c:	10 80 00 03 	b  40007ba8 <vprintk+0x140>                    
40007ba0:	b6 10 20 00 	clr  %i3                                       
  while ((n = unsigned_num / base) > 0) {                             
40007ba4:	b8 10 00 08 	mov  %o0, %i4                                  
    toPrint[count++] = (char) (unsigned_num - (n * base));            
40007ba8:	92 10 00 1c 	mov  %i4, %o1                                  
40007bac:	40 00 47 78 	call  4001998c <.umul>                         
40007bb0:	90 10 00 16 	mov  %l6, %o0                                  
40007bb4:	b4 26 80 08 	sub  %i2, %o0, %i2                             
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
40007bb8:	92 10 00 15 	mov  %l5, %o1                                  
    toPrint[count++] = (char) (unsigned_num - (n * base));            
40007bbc:	f4 2c 00 1b 	stb  %i2, [ %l0 + %i3 ]                        
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
40007bc0:	90 10 00 1c 	mov  %i4, %o0                                  
40007bc4:	40 00 47 ac 	call  40019a74 <.udiv>                         
40007bc8:	b4 10 00 1c 	mov  %i4, %i2                                  
40007bcc:	80 a2 20 00 	cmp  %o0, 0                                    
40007bd0:	12 bf ff f5 	bne  40007ba4 <vprintk+0x13c>                  
40007bd4:	b6 06 e0 01 	inc  %i3                                       
40007bd8:	b4 06 e0 01 	add  %i3, 1, %i2                               
    toPrint[count++] = (char) (unsigned_num - (n * base));            
    unsigned_num = n;                                                 
  }                                                                   
  toPrint[count++] = (char) unsigned_num;                             
40007bdc:	b6 07 80 1b 	add  %fp, %i3, %i3                             
40007be0:	f8 2e ff e8 	stb  %i4, [ %i3 + -24 ]                        
40007be4:	a9 2d 20 18 	sll  %l4, 0x18, %l4                            
                                                                      
  for (n=maxwidth ; n > count; n-- )                                  
40007be8:	80 a6 80 1d 	cmp  %i2, %i5                                  
40007bec:	1a 80 00 08 	bcc  40007c0c <vprintk+0x1a4>                  
40007bf0:	a9 3d 20 18 	sra  %l4, 0x18, %l4                            
    rtems_putc(lead);                                                 
40007bf4:	40 00 16 40 	call  4000d4f4 <rtems_putc>                    
40007bf8:	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-- )                                  
40007bfc:	ba 07 7f ff 	add  %i5, -1, %i5                              
40007c00:	80 a6 80 1d 	cmp  %i2, %i5                                  
40007c04:	0a bf ff fc 	bcs  40007bf4 <vprintk+0x18c>                  
40007c08:	01 00 00 00 	nop                                            
    rtems_putc(lead);                                                 
                                                                      
  for (n = 0; n < count; n++) {                                       
40007c0c:	80 a6 a0 00 	cmp  %i2, 0                                    
40007c10:	22 80 00 0d 	be,a   40007c44 <vprintk+0x1dc>                <== NEVER TAKEN
40007c14:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         <== NOT EXECUTED
    rtems_putc("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);      
40007c18:	ba 06 bf ff 	add  %i2, -1, %i5                              
40007c1c:	b8 14 a1 e0 	or  %l2, 0x1e0, %i4                            
 *  console is not yet initialized or in ISR's.                       
 *                                                                    
 * Arguments:                                                         
 *    as in printf: fmt - format string, ... - unnamed arguments.     
 */                                                                   
void vprintk(                                                         
40007c20:	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)])]);      
40007c24:	c2 4f 40 00 	ldsb  [ %i5 ], %g1                             
40007c28:	ba 07 7f ff 	add  %i5, -1, %i5                              
40007c2c:	40 00 16 32 	call  4000d4f4 <rtems_putc>                    
40007c30:	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++) {                                       
40007c34:	80 a7 40 11 	cmp  %i5, %l1                                  
40007c38:	32 bf ff fc 	bne,a   40007c28 <vprintk+0x1c0>               
40007c3c:	c2 4f 40 00 	ldsb  [ %i5 ], %g1                             
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40007c40:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40007c44:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40007c48:	80 a2 20 00 	cmp  %o0, 0                                    
40007c4c:	12 bf ff 90 	bne  40007a8c <vprintk+0x24>                   <== ALWAYS TAKEN
40007c50:	b0 06 20 01 	inc  %i0                                       
40007c54:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40007c58:	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' ) {                              
40007c5c:	22 80 00 7e 	be,a   40007e54 <vprintk+0x3ec>                
40007c60:	82 10 20 00 	clr  %g1                                       
      base = 10; sign = false;                                        
    } else if ( c == 'x' || c == 'X' ) {                              
40007c64:	80 a0 60 58 	cmp  %g1, 0x58                                 
40007c68:	02 80 00 7d 	be  40007e5c <vprintk+0x3f4>                   
40007c6c:	82 10 20 00 	clr  %g1                                       
      base = 16; sign = false;                                        
    } else if ( c == 'p' ) {                                          
40007c70:	80 a2 20 70 	cmp  %o0, 0x70                                 
40007c74:	02 bf ff bf 	be  40007b70 <vprintk+0x108>                   
40007c78:	aa 10 20 10 	mov  0x10, %l5                                 
      base = 16; sign = false; lflag = true;                          
    } else {                                                          
      rtems_putc(c);                                                  
40007c7c:	40 00 16 1e 	call  4000d4f4 <rtems_putc>                    
40007c80:	01 00 00 00 	nop                                            
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40007c84:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40007c88:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40007c8c:	80 a2 20 00 	cmp  %o0, 0                                    
40007c90:	12 bf ff 7f 	bne  40007a8c <vprintk+0x24>                   
40007c94:	b0 06 20 01 	inc  %i0                                       
40007c98:	30 80 00 6d 	b,a   40007e4c <vprintk+0x3e4>                 
      continue;                                                       
    }                                                                 
                                                                      
    /* must be a numeric format or something unsupported */           
    if ( c == 'o' || c == 'O' ) {                                     
      base = 8; sign = false;                                         
40007c9c:	82 10 20 00 	clr  %g1                                       
40007ca0:	aa 10 20 08 	mov  8, %l5                                    
  unsigned long unsigned_num;                                         
  unsigned long n;                                                    
  unsigned count;                                                     
  char toPrint[20];                                                   
                                                                      
  if ( sign && (num <  0) ) {                                         
40007ca4:	80 a6 a0 00 	cmp  %i2, 0                                    
40007ca8:	16 bf ff b6 	bge  40007b80 <vprintk+0x118>                  <== ALWAYS TAKEN
40007cac:	b2 06 60 04 	add  %i1, 4, %i1                               
40007cb0:	80 88 60 ff 	btst  0xff, %g1                                
40007cb4:	02 bf ff b4 	be  40007b84 <vprintk+0x11c>                   
40007cb8:	90 10 00 1a 	mov  %i2, %o0                                  
    rtems_putc('-');                                                  
40007cbc:	40 00 16 0e 	call  4000d4f4 <rtems_putc>                    
40007cc0:	90 10 20 2d 	mov  0x2d, %o0                                 
    unsigned_num = (unsigned long) -num;                              
    if (maxwidth) maxwidth--;                                         
40007cc4:	80 a0 00 1d 	cmp  %g0, %i5                                  
  unsigned count;                                                     
  char toPrint[20];                                                   
                                                                      
  if ( sign && (num <  0) ) {                                         
    rtems_putc('-');                                                  
    unsigned_num = (unsigned long) -num;                              
40007cc8:	b4 20 00 1a 	neg  %i2                                       
    if (maxwidth) maxwidth--;                                         
40007ccc:	ba 67 60 00 	subx  %i5, 0, %i5                              
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
  while ((n = unsigned_num / base) > 0) {                             
40007cd0:	90 10 00 1a 	mov  %i2, %o0                                  
40007cd4:	40 00 47 68 	call  40019a74 <.udiv>                         
40007cd8:	92 10 00 15 	mov  %l5, %o1                                  
40007cdc:	b8 92 20 00 	orcc  %o0, 0, %i4                              
40007ce0:	32 bf ff af 	bne,a   40007b9c <vprintk+0x134>               <== ALWAYS TAKEN
40007ce4:	ac 10 00 15 	mov  %l5, %l6                                  
40007ce8:	b8 10 00 1a 	mov  %i2, %i4                                  <== NOT EXECUTED
    if (maxwidth) maxwidth--;                                         
  } else {                                                            
    unsigned_num = (unsigned long) num;                               
  }                                                                   
                                                                      
  count = 0;                                                          
40007cec:	b6 10 20 00 	clr  %i3                                       
  while ((n = unsigned_num / base) > 0) {                             
40007cf0:	10 bf ff bb 	b  40007bdc <vprintk+0x174>                    
40007cf4:	b4 10 20 01 	mov  1, %i2                                    
      fmt++;                                                          
    }                                                                 
                                                                      
    if ((c = *fmt) == 'l') {                                          
      lflag = true;                                                   
      c = *++fmt;                                                     
40007cf8:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
40007cfc:	85 28 60 18 	sll  %g1, 0x18, %g2                            
    }                                                                 
    if ( c == 'c' ) {                                                 
40007d00:	91 38 a0 18 	sra  %g2, 0x18, %o0                            
40007d04:	80 a2 20 63 	cmp  %o0, 0x63                                 
40007d08:	12 bf ff 8a 	bne  40007b30 <vprintk+0xc8>                   <== ALWAYS TAKEN
40007d0c:	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);                              
40007d10:	d0 06 40 00 	ld  [ %i1 ], %o0                               <== NOT EXECUTED
40007d14:	b2 06 60 04 	add  %i1, 4, %i1                               
      rtems_putc(chr);                                                
40007d18:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40007d1c:	40 00 15 f6 	call  4000d4f4 <rtems_putc>                    
40007d20:	91 3a 20 18 	sra  %o0, 0x18, %o0                            
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40007d24:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40007d28:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40007d2c:	80 a2 20 00 	cmp  %o0, 0                                    
40007d30:	12 bf ff 57 	bne  40007a8c <vprintk+0x24>                   
40007d34:	b0 06 20 01 	inc  %i0                                       
40007d38:	30 80 00 45 	b,a   40007e4c <vprintk+0x3e4>                 
40007d3c:	c2 0e 20 01 	ldub  [ %i0 + 1 ], %g1                         
    if (*fmt == '0' ) {                                               
      lead = '0';                                                     
      fmt++;                                                          
    }                                                                 
    if (*fmt == '-' ) {                                               
      minus = true;                                                   
40007d40:	88 10 20 01 	mov  1, %g4                                    
      fmt++;                                                          
40007d44:	b0 06 20 01 	inc  %i0                                       
40007d48:	10 bf ff 61 	b  40007acc <vprintk+0x64>                     
40007d4c:	85 28 60 18 	sll  %g1, 0x18, %g2                            
      rtems_putc(*fmt);                                               
      continue;                                                       
    }                                                                 
    fmt++;                                                            
    if (*fmt == '0' ) {                                               
      lead = '0';                                                     
40007d50:	a8 10 20 30 	mov  0x30, %l4                                 
      fmt++;                                                          
40007d54:	b0 06 20 02 	add  %i0, 2, %i0                               
40007d58:	10 bf ff 59 	b  40007abc <vprintk+0x54>                     
40007d5c:	85 28 60 18 	sll  %g1, 0x18, %g2                            
    }                                                                 
    if ( c == 's' ) {                                                 
      unsigned i, len;                                                
      char *s, *str;                                                  
                                                                      
      str = va_arg(ap, char *);                                       
40007d60:	f6 06 40 00 	ld  [ %i1 ], %i3                               
                                                                      
      if ( str == NULL ) {                                            
40007d64:	80 a6 e0 00 	cmp  %i3, 0                                    
40007d68:	02 80 00 3f 	be  40007e64 <vprintk+0x3fc>                   
40007d6c:	b2 06 60 04 	add  %i1, 4, %i1                               
        str = "";                                                     
      }                                                               
                                                                      
      /* calculate length of string */                                
      for ( len=0, s=str ; *s ; len++, s++ )                          
40007d70:	c2 4e c0 00 	ldsb  [ %i3 ], %g1                             
40007d74:	80 a0 60 00 	cmp  %g1, 0                                    
40007d78:	02 80 00 07 	be  40007d94 <vprintk+0x32c>                   
40007d7c:	b8 10 20 00 	clr  %i4                                       
40007d80:	b8 07 20 01 	inc  %i4                                       
40007d84:	c2 4e c0 1c 	ldsb  [ %i3 + %i4 ], %g1                       
40007d88:	80 a0 60 00 	cmp  %g1, 0                                    
40007d8c:	32 bf ff fe 	bne,a   40007d84 <vprintk+0x31c>               
40007d90:	b8 07 20 01 	inc  %i4                                       
        ;                                                             
                                                                      
      /* leading spaces */                                            
      if ( !minus )                                                   
40007d94:	a8 89 20 ff 	andcc  %g4, 0xff, %l4                          
40007d98:	12 80 00 0c 	bne  40007dc8 <vprintk+0x360>                  
40007d9c:	80 a7 60 00 	cmp  %i5, 0                                    
        for ( i=len ; i<width ; i++ )                                 
40007da0:	80 a7 40 1c 	cmp  %i5, %i4                                  
40007da4:	08 80 00 09 	bleu  40007dc8 <vprintk+0x360>                 
40007da8:	80 a7 60 00 	cmp  %i5, 0                                    
40007dac:	b4 10 00 1c 	mov  %i4, %i2                                  
          rtems_putc(' ');                                            
40007db0:	40 00 15 d1 	call  4000d4f4 <rtems_putc>                    
40007db4:	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++ )                                 
40007db8:	b4 06 a0 01 	inc  %i2                                       
40007dbc:	80 a6 80 1d 	cmp  %i2, %i5                                  
40007dc0:	0a bf ff fc 	bcs  40007db0 <vprintk+0x348>                  
40007dc4:	80 a7 60 00 	cmp  %i5, 0                                    
          rtems_putc(' ');                                            
                                                                      
      /* no width option */                                           
      if (width == 0) {                                               
40007dc8:	32 80 00 07 	bne,a   40007de4 <vprintk+0x37c>               
40007dcc:	d0 4e c0 00 	ldsb  [ %i3 ], %o0                             
          width = len;                                                
      }                                                               
                                                                      
      /* output the string */                                         
      for ( i=0 ; i<width && *str ; str++ )                           
40007dd0:	80 a7 20 00 	cmp  %i4, 0                                    
40007dd4:	22 bf ff 9c 	be,a   40007c44 <vprintk+0x1dc>                
40007dd8:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40007ddc:	ba 10 00 1c 	mov  %i4, %i5                                  
40007de0:	d0 4e c0 00 	ldsb  [ %i3 ], %o0                             
40007de4:	80 a2 20 00 	cmp  %o0, 0                                    
40007de8:	02 80 00 08 	be  40007e08 <vprintk+0x3a0>                   <== NEVER TAKEN
40007dec:	b6 06 e0 01 	inc  %i3                                       
        rtems_putc(*str);                                             
40007df0:	40 00 15 c1 	call  4000d4f4 <rtems_putc>                    
40007df4:	01 00 00 00 	nop                                            
      if (width == 0) {                                               
          width = len;                                                
      }                                                               
                                                                      
      /* output the string */                                         
      for ( i=0 ; i<width && *str ; str++ )                           
40007df8:	d0 4e c0 00 	ldsb  [ %i3 ], %o0                             
40007dfc:	80 a2 20 00 	cmp  %o0, 0                                    
40007e00:	12 bf ff fc 	bne  40007df0 <vprintk+0x388>                  
40007e04:	b6 06 e0 01 	inc  %i3                                       
        rtems_putc(*str);                                             
                                                                      
      /* trailing spaces */                                           
      if ( minus )                                                    
40007e08:	80 a5 20 00 	cmp  %l4, 0                                    
40007e0c:	22 bf ff 8e 	be,a   40007c44 <vprintk+0x1dc>                
40007e10:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
        for ( i=len ; i<width ; i++ )                                 
40007e14:	80 a7 40 1c 	cmp  %i5, %i4                                  
40007e18:	28 bf ff 8b 	bleu,a   40007c44 <vprintk+0x1dc>              
40007e1c:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
          rtems_putc(' ');                                            
40007e20:	40 00 15 b5 	call  4000d4f4 <rtems_putc>                    
40007e24:	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++ )                                 
40007e28:	b8 07 20 01 	inc  %i4                                       
40007e2c:	80 a7 00 1d 	cmp  %i4, %i5                                  
40007e30:	0a bf ff fc 	bcs  40007e20 <vprintk+0x3b8>                  
40007e34:	01 00 00 00 	nop                                            
void vprintk(                                                         
  const char *fmt,                                                    
  va_list     ap                                                      
)                                                                     
{                                                                     
  for (; *fmt != '\0'; fmt++) {                                       
40007e38:	d0 0e 20 01 	ldub  [ %i0 + 1 ], %o0                         
40007e3c:	91 2a 20 18 	sll  %o0, 0x18, %o0                            
40007e40:	80 a2 20 00 	cmp  %o0, 0                                    
40007e44:	12 bf ff 12 	bne  40007a8c <vprintk+0x24>                   <== ALWAYS TAKEN
40007e48:	b0 06 20 01 	inc  %i0                                       
40007e4c:	81 c7 e0 08 	ret                                            
40007e50:	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;                                        
40007e54:	10 bf ff 47 	b  40007b70 <vprintk+0x108>                    
40007e58:	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;                          
40007e5c:	10 bf ff 45 	b  40007b70 <vprintk+0x108>                    
40007e60:	aa 10 20 10 	mov  0x10, %l5                                 
      char *s, *str;                                                  
                                                                      
      str = va_arg(ap, char *);                                       
                                                                      
      if ( str == NULL ) {                                            
        str = "";                                                     
40007e64:	10 bf ff c3 	b  40007d70 <vprintk+0x308>                    
40007e68:	b6 14 e1 48 	or  %l3, 0x148, %i3                            
                                                                      

4001cb18 <write>: ssize_t write( int fd, const void *buffer, size_t count ) {
4001cb18:	9d e3 bf a0 	save  %sp, -96, %sp                            
  rtems_libio_t     *iop;                                             
                                                                      
  rtems_libio_check_fd( fd );                                         
4001cb1c:	03 10 00 7d 	sethi  %hi(0x4001f400), %g1                    
4001cb20:	c2 00 61 a4 	ld  [ %g1 + 0x1a4 ], %g1	! 4001f5a4 <rtems_libio_number_iops>
4001cb24:	80 a6 00 01 	cmp  %i0, %g1                                  
4001cb28:	1a 80 00 18 	bcc  4001cb88 <write+0x70>                     
4001cb2c:	03 10 00 80 	sethi  %hi(0x40020000), %g1                    
  iop = rtems_libio_iop( fd );                                        
4001cb30:	d0 00 61 24 	ld  [ %g1 + 0x124 ], %o0	! 40020124 <rtems_libio_iops>
4001cb34:	83 2e 20 03 	sll  %i0, 3, %g1                               
4001cb38:	b1 2e 20 06 	sll  %i0, 6, %i0                               
4001cb3c:	b0 26 00 01 	sub  %i0, %g1, %i0                             
4001cb40:	90 02 00 18 	add  %o0, %i0, %o0                             
  rtems_libio_check_is_open( iop );                                   
4001cb44:	c2 02 20 10 	ld  [ %o0 + 0x10 ], %g1                        
4001cb48:	80 88 61 00 	btst  0x100, %g1                               
4001cb4c:	02 80 00 0f 	be  4001cb88 <write+0x70>                      
4001cb50:	80 a6 60 00 	cmp  %i1, 0                                    
  rtems_libio_check_buffer( buffer );                                 
4001cb54:	02 80 00 13 	be  4001cba0 <write+0x88>                      <== NEVER TAKEN
4001cb58:	80 a6 a0 00 	cmp  %i2, 0                                    
  rtems_libio_check_count( count );                                   
4001cb5c:	02 80 00 0f 	be  4001cb98 <write+0x80>                      
4001cb60:	b0 10 20 00 	clr  %i0                                       
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
4001cb64:	80 88 60 04 	btst  4, %g1                                   
4001cb68:	02 80 00 08 	be  4001cb88 <write+0x70>                      
4001cb6c:	92 10 00 19 	mov  %i1, %o1                                  
                                                                      
  /*                                                                  
   *  Now process the write() request.                                
   */                                                                 
  return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );    
4001cb70:	c2 02 20 24 	ld  [ %o0 + 0x24 ], %g1                        
4001cb74:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
4001cb78:	9f c0 40 00 	call  %g1                                      
4001cb7c:	94 10 00 1a 	mov  %i2, %o2                                  
}                                                                     
4001cb80:	81 c7 e0 08 	ret                                            
4001cb84:	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 );
4001cb88:	7f ff cf 6e 	call  40010940 <__errno>                       
4001cb8c:	b0 10 3f ff 	mov  -1, %i0                                   
4001cb90:	82 10 20 09 	mov  9, %g1                                    
4001cb94:	c2 22 00 00 	st  %g1, [ %o0 ]                               
4001cb98:	81 c7 e0 08 	ret                                            
4001cb9c:	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 );                                 
4001cba0:	7f ff cf 68 	call  40010940 <__errno>                       <== NOT EXECUTED
4001cba4:	b0 10 3f ff 	mov  -1, %i0                                   <== NOT EXECUTED
4001cba8:	82 10 20 16 	mov  0x16, %g1                                 <== NOT EXECUTED
4001cbac:	c2 22 00 00 	st  %g1, [ %o0 ]                               <== NOT EXECUTED
4001cbb0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
4001cbb4:	81 e8 00 00 	restore                                        <== NOT EXECUTED
                                                                      

40008a54 <writev>: ssize_t writev( int fd, const struct iovec *iov, int iovcnt ) {
40008a54:	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 );                                         
40008a58:	03 10 00 62 	sethi  %hi(0x40018800), %g1                    
40008a5c:	c2 00 61 d4 	ld  [ %g1 + 0x1d4 ], %g1	! 400189d4 <rtems_libio_number_iops>
40008a60:	80 a6 00 01 	cmp  %i0, %g1                                  
40008a64:	1a 80 00 4d 	bcc  40008b98 <writev+0x144>                   
40008a68:	03 10 00 65 	sethi  %hi(0x40019400), %g1                    
  iop = rtems_libio_iop( fd );                                        
40008a6c:	f6 00 61 30 	ld  [ %g1 + 0x130 ], %i3	! 40019530 <rtems_libio_iops>
40008a70:	83 2e 20 03 	sll  %i0, 3, %g1                               
40008a74:	b1 2e 20 06 	sll  %i0, 6, %i0                               
40008a78:	b0 26 00 01 	sub  %i0, %g1, %i0                             
40008a7c:	b6 06 c0 18 	add  %i3, %i0, %i3                             
  rtems_libio_check_is_open( iop );                                   
40008a80:	c2 06 e0 10 	ld  [ %i3 + 0x10 ], %g1                        
40008a84:	80 88 61 00 	btst  0x100, %g1                               
40008a88:	02 80 00 44 	be  40008b98 <writev+0x144>                    
40008a8c:	80 88 60 04 	btst  4, %g1                                   
  rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
40008a90:	02 80 00 42 	be  40008b98 <writev+0x144>                    <== NEVER TAKEN
40008a94:	80 a6 60 00 	cmp  %i1, 0                                    
                                                                      
  /*                                                                  
   *  Argument validation on IO vector                                
   */                                                                 
  if ( !iov )                                                         
40008a98:	02 80 00 3a 	be  40008b80 <writev+0x12c>                    
40008a9c:	80 a6 a0 00 	cmp  %i2, 0                                    
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt <= 0 )                                                  
40008aa0:	04 80 00 38 	ble  40008b80 <writev+0x12c>                   
40008aa4:	80 a6 a4 00 	cmp  %i2, 0x400                                
    rtems_set_errno_and_return_minus_one( EINVAL );                   
                                                                      
  if ( iovcnt > IOV_MAX )                                             
40008aa8:	14 80 00 36 	bg  40008b80 <writev+0x12c>                    <== NEVER TAKEN
40008aac:	b5 2e a0 03 	sll  %i2, 3, %i2                               
#include <sys/uio.h>                                                  
                                                                      
#include <rtems/libio_.h>                                             
#include <rtems/seterr.h>                                             
                                                                      
ssize_t writev(                                                       
40008ab0:	82 10 20 00 	clr  %g1                                       
40008ab4:	ba 10 20 01 	mov  1, %i5                                    
40008ab8:	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 )                                       
40008abc:	c6 06 40 01 	ld  [ %i1 + %g1 ], %g3                         
#include <sys/uio.h>                                                  
                                                                      
#include <rtems/libio_.h>                                             
#include <rtems/seterr.h>                                             
                                                                      
ssize_t writev(                                                       
40008ac0:	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 )                                       
40008ac4:	80 a0 e0 00 	cmp  %g3, 0                                    
40008ac8:	02 80 00 2e 	be  40008b80 <writev+0x12c>                    
40008acc:	88 10 20 01 	mov  1, %g4                                    
      rtems_set_errno_and_return_minus_one( EINVAL );                 
                                                                      
    if ( iov[v].iov_len )                                             
40008ad0:	c6 07 20 04 	ld  [ %i4 + 4 ], %g3                           
40008ad4:	82 00 60 08 	add  %g1, 8, %g1                               
      all_zeros = false;                                              
40008ad8:	80 a0 00 03 	cmp  %g0, %g3                                  
40008adc:	b8 40 3f ff 	addx  %g0, -1, %i4                             
                                                                      
    /* check for wrap */                                              
    old    = total;                                                   
    total += iov[v].iov_len;                                          
    if ( total < old || total > SSIZE_MAX )                           
40008ae0:	86 80 c0 02 	addcc  %g3, %g2, %g3                           
40008ae4:	0c 80 00 27 	bneg  40008b80 <writev+0x12c>                  
40008ae8:	ba 0f 40 1c 	and  %i5, %i4, %i5                             
40008aec:	80 a0 80 03 	cmp  %g2, %g3                                  
40008af0:	24 80 00 02 	ble,a   40008af8 <writev+0xa4>                 
40008af4:	88 10 20 00 	clr  %g4                                       
40008af8:	80 89 20 ff 	btst  0xff, %g4                                
40008afc:	12 80 00 21 	bne  40008b80 <writev+0x12c>                   
40008b00:	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++ ) {                    
40008b04:	12 bf ff ee 	bne  40008abc <writev+0x68>                    
40008b08:	84 10 00 03 	mov  %g3, %g2                                  
  }                                                                   
                                                                      
  /*                                                                  
   * A writev with all zeros is supposed to have no effect per OpenGroup.
   */                                                                 
  if ( all_zeros == true ) {                                          
40008b0c:	80 8f 60 ff 	btst  0xff, %i5                                
40008b10:	12 80 00 1a 	bne  40008b78 <writev+0x124>                   
40008b14:	b0 10 20 00 	clr  %i0                                       
40008b18:	10 80 00 05 	b  40008b2c <writev+0xd8>                      
40008b1c:	ba 10 20 00 	clr  %i5                                       
  }                                                                   
                                                                      
  /*                                                                  
   *  Now process the writev().                                       
   */                                                                 
  for ( total=0, v=0 ; v < iovcnt ; v++ ) {                           
40008b20:	80 a7 40 1a 	cmp  %i5, %i2                                  
40008b24:	02 80 00 21 	be  40008ba8 <writev+0x154>                    
40008b28:	01 00 00 00 	nop                                            
#include <sys/uio.h>                                                  
                                                                      
#include <rtems/libio_.h>                                             
#include <rtems/seterr.h>                                             
                                                                      
ssize_t writev(                                                       
40008b2c:	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 )                                        
40008b30:	d4 07 20 04 	ld  [ %i4 + 4 ], %o2                           
40008b34:	80 a2 a0 00 	cmp  %o2, 0                                    
40008b38:	22 bf ff fa 	be,a   40008b20 <writev+0xcc>                  <== NEVER TAKEN
40008b3c:	ba 07 60 08 	add  %i5, 8, %i5                               <== NOT EXECUTED
      continue;                                                       
                                                                      
    bytes = (*iop->pathinfo.handlers->write_h)(                       
40008b40:	c2 06 e0 24 	ld  [ %i3 + 0x24 ], %g1                        
40008b44:	d2 06 40 1d 	ld  [ %i1 + %i5 ], %o1                         
40008b48:	c2 00 60 0c 	ld  [ %g1 + 0xc ], %g1                         
40008b4c:	9f c0 40 00 	call  %g1                                      
40008b50:	90 10 00 1b 	mov  %i3, %o0                                  
      iop,                                                            
      iov[v].iov_base,                                                
      iov[v].iov_len                                                  
    );                                                                
                                                                      
    if ( bytes < 0 )                                                  
40008b54:	80 a2 20 00 	cmp  %o0, 0                                    
40008b58:	06 80 00 16 	bl  40008bb0 <writev+0x15c>                    <== NEVER TAKEN
40008b5c:	01 00 00 00 	nop                                            
      return -1;                                                      
                                                                      
    if ( bytes > 0 ) {                                                
40008b60:	32 80 00 02 	bne,a   40008b68 <writev+0x114>                <== ALWAYS TAKEN
40008b64:	b0 06 00 08 	add  %i0, %o0, %i0                             
      total       += bytes;                                           
    }                                                                 
                                                                      
    if (bytes != iov[ v ].iov_len)                                    
40008b68:	c2 07 20 04 	ld  [ %i4 + 4 ], %g1                           
40008b6c:	80 a2 00 01 	cmp  %o0, %g1                                  
40008b70:	02 bf ff ec 	be  40008b20 <writev+0xcc>                     <== ALWAYS TAKEN
40008b74:	ba 07 60 08 	add  %i5, 8, %i5                               
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
40008b78:	81 c7 e0 08 	ret                                            
40008b7c:	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 );                 
40008b80:	40 00 21 c1 	call  40011284 <__errno>                       
40008b84:	b0 10 3f ff 	mov  -1, %i0                                   
40008b88:	82 10 20 16 	mov  0x16, %g1                                 
40008b8c:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40008b90:	81 c7 e0 08 	ret                                            
40008b94:	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 );
40008b98:	40 00 21 bb 	call  40011284 <__errno>                       
40008b9c:	b0 10 3f ff 	mov  -1, %i0                                   
40008ba0:	82 10 20 09 	mov  9, %g1                                    
40008ba4:	c2 22 00 00 	st  %g1, [ %o0 ]                               
40008ba8:	81 c7 e0 08 	ret                                            
40008bac:	81 e8 00 00 	restore                                        
    if (bytes != iov[ v ].iov_len)                                    
      break;                                                          
  }                                                                   
                                                                      
  return total;                                                       
}                                                                     
40008bb0:	81 c7 e0 08 	ret                                            <== NOT EXECUTED
40008bb4:	91 e8 3f ff 	restore  %g0, -1, %o0                          <== NOT EXECUTED